linkedin-automation-cli 1.0.0

package/src/core/config.ts

@@ -0,0 +1,81 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface Config {
+  headless: boolean;
+  rateLimit: number;
+  sessionTimeout: number;
+  dryRun: boolean;
+  dataDir: string;
+}
+
+const DEFAULT_CONFIG: Config = {
+  headless: true,
+  rateLimit: 5000,
+  sessionTimeout: 86400000,
+  dryRun: false,
+  dataDir: path.join(os.homedir(), '.linkedin-cli'),
+};
+
+export class ConfigManager {
+  private config: Config;
+  private configPath: string;
+
+  constructor() {
+    this.configPath = path.join(os.homedir(), '.linkedin-cli', 'config.json');
+    this.config = this.loadConfig();
+  }
+
+  private loadConfig(): Config {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const data = fs.readFileSync(this.configPath, 'utf-8');
+        const parsed = JSON.parse(data);
+        return { ...DEFAULT_CONFIG, ...parsed };
+      }
+    } catch (error) {
+      console.warn('Failed to load config, using defaults:', error);
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+
+  private saveConfig(): void {
+    try {
+      const dir = path.dirname(this.configPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+    } catch (error) {
+      console.error('Failed to save config:', error);
+    }
+  }
+
+  get(): Config {
+    return { ...this.config };
+  }
+
+  getValue<K extends keyof Config>(key: K): Config[K] {
+    return this.config[key];
+  }
+
+  set<K extends keyof Config>(key: K, value: Config[K]): void {
+    this.config[key] = value;
+    this.saveConfig();
+  }
+
+  reset(): void {
+    this.config = { ...DEFAULT_CONFIG };
+    this.saveConfig();
+  }
+}
+
+let configManager: ConfigManager | null = null;
+
+export function getConfig(): ConfigManager {
+  if (!configManager) {
+    configManager = new ConfigManager();
+  }
+  return configManager;
+}

package/src/core/storage.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// Mock the paths module
+vi.mock('../utils/paths', () => {
+  const testDir = path.join(os.tmpdir(), 'linkedin-cli-test');
+  return {
+    getConfigDir: () => testDir,
+    getSessionsDir: () => path.join(testDir, 'sessions'),
+    getTemplatesDir: () => path.join(testDir, 'templates'),
+    getDefaultsDir: () => path.join(testDir, 'templates', 'defaults'),
+    getCustomDir: () => path.join(testDir, 'templates', 'custom'),
+    getConfigFile: () => path.join(testDir, 'config.json'),
+    getLogFile: () => path.join(testDir, 'audit.log'),
+  };
+});
+
+import { SecureStorage, encrypt, decrypt } from './storage';
+
+describe('SecureStorage', () => {
+  let storage: SecureStorage;
+  const testDir = path.join(os.tmpdir(), 'linkedin-cli-test');
+
+  beforeEach(() => {
+    // Clean up test directory
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+    storage = new SecureStorage();
+  });
+
+  afterEach(() => {
+    // Clean up after tests
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('save and load', () => {
+    it('should save and retrieve data', () => {
+      const testData = 'test-secret-data';
+      storage.save('test-key', testData);
+
+      const loaded = storage.load('test-key');
+      expect(loaded).toBe(testData);
+    });
+
+    it('should return null for non-existent key', () => {
+      const loaded = storage.load('non-existent-key');
+      expect(loaded).toBeNull();
+    });
+
+    it('should overwrite existing key', () => {
+      storage.save('test-key', 'first-value');
+      storage.save('test-key', 'second-value');
+
+      const loaded = storage.load('test-key');
+      expect(loaded).toBe('second-value');
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete existing key and return true', () => {
+      storage.save('test-key', 'test-data');
+      const deleted = storage.delete('test-key');
+
+      expect(deleted).toBe(true);
+      expect(storage.load('test-key')).toBeNull();
+    });
+
+    it('should return false for non-existent key', () => {
+      const deleted = storage.delete('non-existent-key');
+      expect(deleted).toBe(false);
+    });
+  });
+
+  describe('exists', () => {
+    it('should return true for existing key', () => {
+      storage.save('test-key', 'test-data');
+      expect(storage.exists('test-key')).toBe(true);
+    });
+
+    it('should return false for non-existent key', () => {
+      expect(storage.exists('non-existent-key')).toBe(false);
+    });
+  });
+});
+
+describe('encryption', () => {
+  it('should encrypt and decrypt data correctly', () => {
+    const originalData = 'sensitive-information';
+    const encrypted = encrypt(originalData);
+
+    expect(encrypted).toHaveProperty('encrypted');
+    expect(encrypted).toHaveProperty('iv');
+    expect(encrypted).toHaveProperty('salt');
+    expect(encrypted).toHaveProperty('tag');
+
+    const decrypted = decrypt(encrypted);
+    expect(decrypted).toBe(originalData);
+  });
+
+  it('should produce different encrypted output each time', () => {
+    const data = 'test-data';
+    const encrypted1 = encrypt(data);
+    const encrypted2 = encrypt(data);
+
+    // Salt should be different (random)
+    expect(encrypted1.salt).not.toBe(encrypted2.salt);
+    // But both should decrypt to the same value
+    expect(decrypt(encrypted1)).toBe(data);
+    expect(decrypt(encrypted2)).toBe(data);
+  });
+
+  it('should throw on tampered data', () => {
+    const originalData = 'important-data';
+    const encrypted = encrypt(originalData);
+
+    // Tamper with the encrypted data
+    const tampered = {
+      ...encrypted,
+      encrypted: encrypted.encrypted.split('').reverse().join(''),
+    };
+
+    expect(() => decrypt(tampered)).toThrow();
+  });
+});

package/src/core/storage.ts

@@ -0,0 +1,100 @@
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+import * as path from 'path';
+import { getSessionsDir } from '../utils/paths';
+
+const ALGORITHM = 'aes-256-gcm';
+const KEY_LENGTH = 32;
+const IV_LENGTH = 16;
+const SALT_LENGTH = 32;
+
+function deriveKey(salt: Buffer): Buffer {
+  const machineData = [
+    process.env.USER || process.env.USERNAME || 'unknown',
+    process.env.HOME || process.env.USERPROFILE || 'unknown',
+    process.platform,
+  ].join('|');
+  return crypto.pbkdf2Sync(machineData, salt, 100000, KEY_LENGTH, 'sha256');
+}
+
+export interface EncryptedData {
+  encrypted: string;
+  iv: string;
+  salt: string;
+  tag: string;
+}
+
+export function encrypt(data: string): EncryptedData {
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const key = deriveKey(salt);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([cipher.update(data, 'utf8'), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    encrypted: encrypted.toString('base64'),
+    iv: iv.toString('base64'),
+    salt: salt.toString('base64'),
+    tag: tag.toString('base64'),
+  };
+}
+
+export function decrypt(data: EncryptedData): string {
+  const salt = Buffer.from(data.salt, 'base64');
+  const iv = Buffer.from(data.iv, 'base64');
+  const key = deriveKey(salt);
+  const encrypted = Buffer.from(data.encrypted, 'base64');
+  const tag = Buffer.from(data.tag, 'base64');
+  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+  return decrypted.toString('utf8');
+}
+
+export class SecureStorage {
+  private baseDir: string;
+
+  constructor() {
+    this.baseDir = getSessionsDir();
+    this.ensureDir();
+  }
+
+  private ensureDir(): void {
+    if (!fs.existsSync(this.baseDir)) {
+      fs.mkdirSync(this.baseDir, { recursive: true, mode: 0o700 });
+    }
+  }
+
+  save(key: string, data: string): void {
+    const encrypted = encrypt(data);
+    const filePath = path.join(this.baseDir, `${key}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(encrypted, null, 2), { mode: 0o600 });
+  }
+
+  load(key: string): string | null {
+    const filePath = path.join(this.baseDir, `${key}.json`);
+    if (!fs.existsSync(filePath)) return null;
+    const encrypted = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return decrypt(encrypted);
+  }
+
+  delete(key: string): boolean {
+    const filePath = path.join(this.baseDir, `${key}.json`);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      return true;
+    }
+    return false;
+  }
+
+  exists(key: string): boolean {
+    const filePath = path.join(this.baseDir, `${key}.json`);
+    return fs.existsSync(filePath);
+  }
+}
+
+let secureStorage: SecureStorage | null = null;
+export function getSecureStorage(): SecureStorage {
+  if (!secureStorage) secureStorage = new SecureStorage();
+  return secureStorage;
+}

package/src/index.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import chalk from 'chalk';
+import {
+  registerAuthCommands,
+  registerMessageCommands,
+  registerReplyCommands,
+  registerConnectionCommands,
+  registerCompanyCommands,
+  registerProfileCommands,
+} from './cli';
+import { getConfig } from './core/config';
+
+const packageJson = require('../package.json');
+
+program
+  .name('linkedin-cli')
+  .description('LinkedIn automation CLI for sales representatives')
+  .version(packageJson.version);
+
+// Register command groups
+registerAuthCommands(program);
+registerMessageCommands(program);
+registerReplyCommands(program);
+registerConnectionCommands(program);
+registerCompanyCommands(program);
+registerProfileCommands(program);
+
+// Config command
+program
+  .command('config')
+  .description('Manage configuration')
+  .option('--get', 'Show current configuration')
+  .option('--set <key=value>', 'Set a configuration value')
+  .action((options) => {
+    const config = getConfig();
+
+    if (options.get || !options.set) {
+      console.log(chalk.bold('Current Configuration:'));
+      console.log(JSON.stringify(config.get(), null, 2));
+      return;
+    }
+
+    if (options.set) {
+      const [key, value] = options.set.split('=');
+      if (!key || value === undefined) {
+        console.error(chalk.red('Invalid format. Use: --set key=value'));
+        process.exit(1);
+      }
+
+      // Try to parse as boolean or number
+      let parsedValue: string | boolean | number = value;
+      if (value === 'true') parsedValue = true;
+      else if (value === 'false') parsedValue = false;
+      else if (!isNaN(Number(value))) parsedValue = Number(value);
+
+      config.set(key as any, parsedValue as any);
+      console.log(chalk.green(`✓ Set ${key} = ${parsedValue}`));
+    }
+  });
+
+// Global error handler
+program.exitOverride();
+
+try {
+  program.parse();
+} catch (error) {
+  console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+  process.exit(1);
+}

package/src/linkedin/auth.ts

@@ -0,0 +1,218 @@
+import type { BrowserController } from '../core/browser';
+import type { Session } from '../types';
+import { SELECTORS } from './selectors';
+
+export interface LoginCredentials {
+  email: string;
+  password: string;
+  totpCode?: string;
+}
+
+export interface LoginResult {
+  success: boolean;
+  session?: Session;
+  error?: string;
+  requires2FA?: boolean;
+}
+
+export class LinkedInAuth {
+  private browser: BrowserController;
+  private debug: boolean;
+
+  constructor(browser: BrowserController, debug: boolean = false) {
+    this.browser = browser;
+    this.debug = debug;
+  }
+  private async findElementWithFallbacks(
+    selectors: readonly string[],
+    elementName: string
+  ): Promise<{
+    element: Awaited<ReturnType<import('playwright').Page['$']>>;
+    selectorUsed: string;
+  } | null> {
+    const page = this.browser.getPage();
+    if (!page) return null;
+
+    for (const selector of selectors) {
+      try {
+        const element = await page.$(selector);
+        if (element) {
+          console.log(`Found ${elementName} using selector: ${selector}`);
+          if (this.debug) this.browser.debugLog(`Found ${elementName} using selector: ${selector}`);
+          return { element, selectorUsed: selector };
+        }
+      } catch {
+        // Continue to next selector
+      }
+    }
+
+    return null;
+  }
+
+  async login(credentials: LoginCredentials): Promise<LoginResult> {
+    const page = this.browser.getPage();
+    if (!page) {
+      return { success: false, error: 'Browser not initialized' };
+    }
+
+    try {
+      // Navigate to LinkedIn login
+      console.log('Navigating to LinkedIn login page...');
+      await page.goto('https://www.linkedin.com/login', {
+        waitUntil: 'domcontentloaded',
+        timeout: 30000,
+      });
+
+      const currentUrl = page.url();
+      console.log(`Current page URL: ${currentUrl}`);
+
+      // Debug: Log all input elements on the page
+      console.log('Scanning for form elements...');
+      const inputs = await page.$$('input');
+      console.log(`Found ${inputs.length} input elements`);
+      for (let i = 0; i < Math.min(inputs.length, 5); i++) {
+        const type = await inputs[i].getAttribute('type');
+        const id = await inputs[i].getAttribute('id');
+        const name = await inputs[i].getAttribute('name');
+        console.log(`  Input ${i}: type=${type}, id=${id}, name=${name}`);
+      }
+
+      // Find and fill email input
+      console.log('Looking for email input...');
+      const emailResult = await this.findElementWithFallbacks(
+        SELECTORS.login.emailInput,
+        'email input'
+      );
+      if (!emailResult) {
+        return {
+          success: false,
+          error:
+            'Could not find email input field - LinkedIn may have changed their page structure',
+        };
+      }
+      await page.fill(emailResult.selectorUsed, credentials.email);
+      console.log('Email filled successfully');
+
+      // Find and fill password input
+      console.log('Looking for password input...');
+      const passwordResult = await this.findElementWithFallbacks(
+        SELECTORS.login.passwordInput,
+        'password input'
+      );
+      if (!passwordResult) {
+        return {
+          success: false,
+          error:
+            'Could not find password input field - LinkedIn may have changed their page structure',
+        };
+      }
+      await page.fill(passwordResult.selectorUsed, credentials.password);
+      console.log('Password filled successfully');
+
+      // Find and click submit button
+      console.log('Looking for submit button...');
+      const submitResult = await this.findElementWithFallbacks(
+        SELECTORS.login.submitButton,
+        'submit button'
+      );
+      if (!submitResult) {
+        return {
+          success: false,
+          error: 'Could not find submit button - LinkedIn may have changed their page structure',
+        };
+      }
+      if (!submitResult.element) {
+        return {
+          success: false,
+          error: 'Submit button element is null',
+        };
+      }
+      await submitResult.element.click();
+      console.log('Submit button clicked');
+
+      // Wait for navigation or 2FA prompt
+      console.log('Waiting for page to load...');
+      await page.waitForLoadState('networkidle');
+
+      // Check for 2FA prompt
+      console.log('Checking for 2FA prompt...');
+      const has2FA = await this.findElementWithFallbacks(SELECTORS.twoFA.pinInput, '2FA pin input');
+      if (has2FA) {
+        console.log('2FA prompt detected');
+        if (credentials.totpCode) {
+          // Fill in TOTP code
+          await page.fill(has2FA.selectorUsed, credentials.totpCode);
+          const submit2FA = await this.findElementWithFallbacks(
+            SELECTORS.twoFA.submitButton,
+            '2FA submit button'
+          );
+          if (submit2FA && submit2FA.element) {
+            await submit2FA.element.click();
+          }
+          await page.waitForLoadState('networkidle');
+        } else {
+          return { success: false, requires2FA: true, error: '2FA required - provide TOTP code' };
+        }
+      }
+
+      // Check if login succeeded (look for feed or profile element)
+      console.log('Checking if login was successful...');
+      const navElement = await this.findElementWithFallbacks(
+        SELECTORS.nav.globalNav,
+        'global navigation'
+      );
+      if (!navElement) {
+        // Check for error message
+        const errorElement = await page.$('div[role="alert"] div, div.error, .alert-content');
+        const errorText = errorElement ? await errorElement.textContent() : null;
+
+        if (errorText) {
+          return { success: false, error: `LinkedIn error: ${errorText.trim()}` };
+        }
+
+        // Take a screenshot for debugging
+        console.log('Login may have failed - no global nav found');
+        return { success: false, error: 'Login failed - could not verify successful login' };
+      }
+
+      console.log('Login successful! Saving session...');
+
+      // Save session
+      const session = await this.browser.saveSession();
+      if (!session) {
+        return { success: false, error: 'Failed to save session' };
+      }
+
+      console.log('Session saved successfully');
+      return { success: true, session };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error('Login error:', errorMessage);
+      return {
+        success: false,
+        error: `Login error: ${errorMessage}`,
+      };
+    }
+  }
+
+  async isSessionValid(): Promise<boolean> {
+    const page = this.browser.getPage();
+    if (!page) return false;
+
+    try {
+      // Navigate to LinkedIn and check if we're logged in
+      await page.goto('https://www.linkedin.com/feed', {
+        waitUntil: 'domcontentloaded',
+        timeout: 10000,
+      });
+
+      const navElement = await this.findElementWithFallbacks(
+        SELECTORS.nav.globalNav,
+        'global navigation'
+      );
+      return !!navElement;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/linkedin/company-extractor.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { isValidCompanyUrl, parseFollowerCount, parseSpecialties } from './company-extractor';
+
+describe('isValidCompanyUrl', () => {
+  it('should accept valid HTTPS company URLs', () => {
+    expect(isValidCompanyUrl('https://www.linkedin.com/company/openai/')).toBe(true);
+    expect(isValidCompanyUrl('https://www.linkedin.com/company/microsoft')).toBe(true);
+    expect(isValidCompanyUrl('https://www.linkedin.com/company/123company/')).toBe(true);
+  });
+
+  it('should reject invalid URLs', () => {
+    expect(isValidCompanyUrl('http://www.linkedin.com/company/openai/')).toBe(false);
+    expect(isValidCompanyUrl('https://linkedin.com/company/openai/')).toBe(false);
+    expect(isValidCompanyUrl('https://www.linkedin.com/in/openai/')).toBe(false);
+    expect(isValidCompanyUrl('not-a-url')).toBe(false);
+    expect(isValidCompanyUrl('')).toBe(false);
+  });
+});
+
+describe('parseFollowerCount', () => {
+  it('should parse K suffix', () => {
+    expect(parseFollowerCount('12K followers')).toBe(12000);
+    expect(parseFollowerCount('5k')).toBe(5000);
+  });
+
+  it('should parse M suffix', () => {
+    expect(parseFollowerCount('2.5M followers')).toBe(2500000);
+    expect(parseFollowerCount('1.2m')).toBe(1200000);
+  });
+
+  it('should parse plain numbers with commas', () => {
+    expect(parseFollowerCount('1,234 followers')).toBe(1234);
+    expect(parseFollowerCount('500+ followers')).toBe(500);
+  });
+
+  it('should return null for invalid input', () => {
+    expect(parseFollowerCount(null)).toBe(null);
+    expect(parseFollowerCount('')).toBe(null);
+    expect(parseFollowerCount('no numbers')).toBe(null);
+  });
+});
+
+describe('parseSpecialties', () => {
+  it('should split by comma and trim', () => {
+    expect(parseSpecialties('AI, ML, Research')).toEqual(['AI', 'ML', 'Research']);
+    expect(parseSpecialties('Artificial Intelligence')).toEqual(['Artificial Intelligence']);
+  });
+
+  it('should handle whitespace', () => {
+    expect(parseSpecialties('  AI  ,  ML  ')).toEqual(['AI', 'ML']);
+  });
+
+  it('should return null for empty input', () => {
+    expect(parseSpecialties(null)).toBe(null);
+    expect(parseSpecialties('')).toBe(null);
+    expect(parseSpecialties('   ')).toBe(null);
+  });
+});