linkedin-automation-cli 1.0.0

package/internal/ratelimit/limiter.go

@@ -0,0 +1,115 @@
+package ratelimit
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+
+	"github.com/thaddeus-git/linkedin-cli/internal/config"
+)
+
+// Limiter handles rate limiting logic
+type Limiter struct {
+	limits  Limits
+	config  *config.Manager
+	profile string
+}
+
+// NewLimiter creates a new rate limiter
+func NewLimiter(profile string, limits Limits, cfg *config.Manager) *Limiter {
+	return &Limiter{
+		limits:  limits,
+		config:  cfg,
+		profile: profile,
+	}
+}
+
+// CheckConnection checks if a connection request is allowed
+func (l *Limiter) CheckConnection() error {
+	state, err := l.config.LoadRateLimits(l.profile)
+	if err != nil {
+		return fmt.Errorf("failed to load rate limits: %w", err)
+	}
+
+	if !state.CanConnect(l.limits.ConnectionsDaily, l.limits.ConnectionsWeekly) {
+		return fmt.Errorf(
+			"rate limit exceeded: %d/%d daily, %d/%d weekly connections",
+			state.Connections.Today,
+			l.limits.ConnectionsDaily,
+			state.Connections.ThisWeek,
+			l.limits.ConnectionsWeekly,
+		)
+	}
+
+	return nil
+}
+
+// CheckMessage checks if a message is allowed
+func (l *Limiter) CheckMessage() error {
+	state, err := l.config.LoadRateLimits(l.profile)
+	if err != nil {
+		return fmt.Errorf("failed to load rate limits: %w", err)
+	}
+
+	if !state.CanMessage(l.limits.MessagesDaily) {
+		return fmt.Errorf(
+			"rate limit exceeded: %d/%d daily messages",
+			state.Messages.Today,
+			l.limits.MessagesDaily,
+		)
+	}
+
+	return nil
+}
+
+// RecordConnection records a connection request
+func (l *Limiter) RecordConnection() error {
+	state, err := l.config.LoadRateLimits(l.profile)
+	if err != nil {
+		return err
+	}
+
+	state.RecordConnection()
+	return l.config.SaveRateLimits(l.profile, state)
+}
+
+// RecordMessage records a message
+func (l *Limiter) RecordMessage() error {
+	state, err := l.config.LoadRateLimits(l.profile)
+	if err != nil {
+		return err
+	}
+
+	state.RecordMessage()
+	return l.config.SaveRateLimits(l.profile, state)
+}
+
+// GetDelay returns a random delay between min and max seconds
+func (l *Limiter) GetDelay() time.Duration {
+	seconds := rand.Intn(l.limits.MaxDelaySeconds-l.limits.MinDelaySeconds+1) + l.limits.MinDelaySeconds
+	return time.Duration(seconds) * time.Second
+}
+
+// Sleep delays execution for a random duration
+func (l *Limiter) Sleep() {
+	time.Sleep(l.GetDelay())
+}
+
+// Status returns current rate limit status
+func (l *Limiter) Status() (map[string]interface{}, error) {
+	state, err := l.config.LoadRateLimits(l.profile)
+	if err != nil {
+		return nil, err
+	}
+
+	return map[string]interface{}{
+		"connections_today":        state.Connections.Today,
+		"connections_weekly":       state.Connections.ThisWeek,
+		"connections_limit":        l.limits.ConnectionsDaily,
+		"connections_weekly_limit": l.limits.ConnectionsWeekly,
+		"messages_today":           state.Messages.Today,
+		"messages_limit":           l.limits.MessagesDaily,
+		"last_connection":          state.Connections.LastAction,
+		"last_message":             state.Messages.LastAction,
+	}, nil
+}

package/internal/ratelimit/limits.go

@@ -0,0 +1,32 @@
+package ratelimit
+
+// Limits defines rate limit thresholds
+type Limits struct {
+	ConnectionsDaily  int
+	ConnectionsWeekly int
+	MessagesDaily     int
+	MinDelaySeconds   int
+	MaxDelaySeconds   int
+}
+
+// DefaultLimits returns default LinkedIn-safe limits
+func DefaultLimits() Limits {
+	return Limits{
+		ConnectionsDaily:  20,
+		ConnectionsWeekly: 100,
+		MessagesDaily:     50,
+		MinDelaySeconds:   3,
+		MaxDelaySeconds:   8,
+	}
+}
+
+// ConservativeLimits returns more conservative limits for new accounts
+func ConservativeLimits() Limits {
+	return Limits{
+		ConnectionsDaily:  10,
+		ConnectionsWeekly: 50,
+		MessagesDaily:     25,
+		MinDelaySeconds:   5,
+		MaxDelaySeconds:   12,
+	}
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "linkedin-automation-cli",
+  "version": "1.0.0",
+  "description": "A CLI tool for LinkedIn automation using Playwright",
+  "main": "dist/index.js",
+  "bin": {
+    "linkedin-automation": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "watch": "nodemon --exec ts-node src/index.ts",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepare": "husky"
+  },
+  "keywords": [
+    "linkedin",
+    "automation",
+    "playwright",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@types/ws": "^8.18.1",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "dotenv": "^16.3.1",
+    "inquirer": "^9.2.12",
+    "ora": "^5.4.1",
+    "playwright": "^1.40.0",
+    "sql.js": "^1.14.0",
+    "ws": "^8.19.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.10.0",
+    "@typescript-eslint/eslint-plugin": "^6.13.0",
+    "@typescript-eslint/parser": "^6.13.0",
+    "@vitest/coverage-v8": "^1.0.4",
+    "eslint": "^8.54.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-playwright": "^0.19.0",
+    "husky": "^9.0.6",
+    "nodemon": "^3.0.2",
+    "prettier": "^3.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.2",
+    "vitest": "^1.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/release.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+
+# LinkedIn CLI Release Script
+# Usage: ./release.sh [patch|minor|major]
+
+set -e
+
+BUMP_TYPE="${1:-patch}"
+WORKTREE_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+echo "🚀 LinkedIn CLI Release Script"
+echo "=============================="
+echo "Worktree: $WORKTREE_DIR"
+echo "Version bump: $BUMP_TYPE"
+echo ""
+
+# Step 1: Run quality checks
+echo "📋 Running quality checks..."
+npm run typecheck || { echo "❌ Type check failed"; exit 1; }
+npm run lint || { echo "❌ Lint failed"; exit 1; }
+npm run format || { echo "❌ Format failed"; exit 1; }
+npm run test:coverage || { echo "❌ Tests failed"; exit 1; }
+
+# Step 2: Build
+echo "🔨 Building project..."
+npm run build || { echo "❌ Build failed"; exit 1; }
+
+# Step 3: Commit changes
+echo "💾 Committing changes..."
+git add -A
+if git diff-index --quiet HEAD; then
+    echo "No changes to commit"
+else
+    git commit -m "chore: release preparations (auto-generated)"
+fi
+
+# Step 4: Merge to main
+echo "🔄 Merging to main..."
+git checkout main
+git merge linkedin-automation-cli -m "Merge linkedin-automation-cli into main"
+
+# Step 5: Push to GitHub
+echo "⬆️  Pushing to GitHub..."
+git push origin main
+
+# Step 6: Create version tag
+echo "🏷️  Creating version tag..."
+npm version $BUMP_TYPE --no-git-tag-version
+NEW_VERSION=$(node -p "require('./package.json').version")
+git commit -am "chore: bump version to v$NEW_VERSION"
+git tag -a "v$NEW_VERSION" -m "Release v$NEW_VERSION"
+git push origin --tags
+
+echo ""
+echo "✅ Release complete!"
+echo "📦 Version: v$NEW_VERSION"
+echo "🔗 GitHub: https://github.com/thaddeus-git/linkedin-cli"
+echo "📊 Actions: https://github.com/thaddeus-git/linkedin-cli/actions"
+echo ""
+echo "GitHub Actions is now:"
+echo "  1. Running CI checks"
+echo "  2. Publishing to npm"
+echo "  3. Creating GitHub Release"
+echo ""
+echo "Manual npm publish (if needed):"
+echo "  npm login && npm publish --access public"

package/scripts/debug-linkedin.js

@@ -0,0 +1,156 @@
+const { chromium } = require('playwright');
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_DIR = path.join(require('os').homedir(), '.linkedin-cli');
+const SESSIONS_DIR = path.join(CONFIG_DIR, 'sessions');
+
+async function debugLinkedIn() {
+  console.log('🔍 LinkedIn Debug Tool');
+  console.log('======================\n');
+
+  // Load session
+  const sessionFile = path.join(SESSIONS_DIR, 'linkedin-session.json');
+  if (!fs.existsSync(sessionFile)) {
+    console.error('❌ No session found. Run auth login first.');
+    return;
+  }
+
+  const encrypted = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+  
+  // Simple decryption (matching the CLI's method)
+  const crypto = require('crypto');
+  const machineData = [
+    process.env.USER || process.env.USERNAME || 'unknown',
+    process.env.HOME || process.env.USERPROFILE || 'unknown',
+    process.platform,
+  ].join('|');
+  
+  const salt = Buffer.from(encrypted.salt, 'base64');
+  const key = crypto.pbkdf2Sync(machineData, salt, 100000, 32, 'sha256');
+  const iv = Buffer.from(encrypted.iv, 'base64');
+  const encryptedData = Buffer.from(encrypted.encrypted, 'base64');
+  const tag = Buffer.from(encrypted.tag, 'base64');
+  
+  const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
+  const sessionData = JSON.parse(decrypted.toString('utf8'));
+
+  console.log('✓ Session loaded');
+  console.log(`  User ID: ${sessionData.cookies.find(c => c.name === 'li_at')?.value?.substring(0, 50)}...`);
+
+  // Launch browser
+  const browser = await chromium.launch({ headless: false });
+  const context = await browser.newContext({
+    userAgent: sessionData.userAgent,
+    viewport: { width: 1280, height: 800 }
+  });
+
+  // Set cookies
+  const cookies = sessionData.cookies.map(c => ({
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path || '/',
+    secure: c.secure,
+    httpOnly: false,
+    sameSite: 'Lax'
+  }));
+  
+  await context.addCookies(cookies);
+  console.log('✓ Cookies set\n');
+
+  // Try to access feed
+  console.log('📰 Checking Feed...');
+  const feedPage = await context.newPage();
+  await feedPage.goto('https://www.linkedin.com/feed/', { waitUntil: 'domcontentloaded', timeout: 30000 });
+  await feedPage.waitForTimeout(3000);
+  
+  const feedTitle = await feedPage.title();
+  console.log(`  Page title: ${feedTitle}`);
+  
+  // Take screenshot of feed
+  await feedPage.screenshot({ path: '/tmp/linkedin-feed.png', fullPage: false });
+  console.log('  📸 Screenshot saved: /tmp/linkedin-feed.png');
+  
+  // Get feed posts
+  const posts = await feedPage.$$eval('.feed-shared-update-v2, .scaffold-finite-scroll__content > div', elements => 
+    elements.slice(0, 3).map(el => ({
+      text: el.innerText?.substring(0, 200),
+      author: el.querySelector('[class*="actor"], [class*="author"]')?.innerText
+    }))
+  );
+  
+  if (posts.length > 0) {
+    console.log(`  ✓ Found ${posts.length} posts in feed`);
+    posts.forEach((post, i) => {
+      console.log(`\n  Post ${i + 1}:`);
+      console.log(`    Author: ${post.author || 'Unknown'}`);
+      console.log(`    Preview: ${post.text?.substring(0, 100)}...`);
+    });
+  } else {
+    console.log('  ⚠ No posts found - checking page structure...');
+  }
+
+  // Try to access messages
+  console.log('\n💬 Checking Messages...');
+  const msgPage = await context.newPage();
+  await msgPage.goto('https://www.linkedin.com/messaging/', { waitUntil: 'domcontentloaded', timeout: 30000 });
+  await msgPage.waitForTimeout(3000);
+  
+  const msgTitle = await msgPage.title();
+  console.log(`  Page title: ${msgTitle}`);
+  
+  // Take screenshot of messages
+  await msgPage.screenshot({ path: '/tmp/linkedin-messages.png', fullPage: false });
+  console.log('  📸 Screenshot saved: /tmp/linkedin-messages.png');
+  
+  // Get conversation list
+  const conversations = await msgPage.$$eval('.msg-conversation-card, [data-testid="conversation-card"], div[class*="conversation"]', elements =>
+    elements.slice(0, 5).map(el => ({
+      name: el.querySelector('[class*="participant"], [class*="name"]')?.innerText,
+      preview: el.querySelector('[class*="preview"], [class*="message"]')?.innerText,
+      unread: el.querySelector('[class*="unread"]') !== null
+    }))
+  );
+  
+  if (conversations.length > 0) {
+    console.log(`  ✓ Found ${conversations.length} conversations`);
+    conversations.forEach((conv, i) => {
+      console.log(`\n  Conversation ${i + 1}:`);
+      console.log(`    From: ${conv.name || 'Unknown'} ${conv.unread ? '(UNREAD)' : ''}`);
+      console.log(`    Preview: ${conv.preview?.substring(0, 80) || 'No preview'}...`);
+    });
+  } else {
+    console.log('  ⚠ No conversations found');
+    
+    // Debug: list all divs with class names containing 'conversation' or 'message'
+    const debugInfo = await msgPage.evaluate(() => {
+      const convElements = document.querySelectorAll('div[class*="conversation"], div[class*="message"], div[class*="msg-"]');
+      return Array.from(convElements).slice(0, 10).map(el => ({
+        className: el.className,
+        text: el.innerText?.substring(0, 50)
+      }));
+    });
+    
+    if (debugInfo.length > 0) {
+      console.log('  🔍 Debug: Found elements with conversation/message classes:');
+      debugInfo.forEach((info, i) => {
+        console.log(`    ${i + 1}. Class: ${info.className?.substring(0, 60)}...`);
+      });
+    }
+  }
+
+  console.log('\n✅ Debug complete!');
+  console.log('\nScreenshots saved:');
+  console.log('  - /tmp/linkedin-feed.png');
+  console.log('  - /tmp/linkedin-messages.png');
+  
+  await browser.close();
+}
+
+debugLinkedIn().catch(error => {
+  console.error('❌ Error:', error.message);
+  process.exit(1);
+});

package/scripts/debug-login.js

@@ -0,0 +1,193 @@
+const { chromium } = require('playwright');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const CONFIG_DIR = path.join(require('os').homedir(), '.linkedin-cli');
+const SCREENSHOT_DIR = path.join(CONFIG_DIR, 'debug');
+
+function askQuestion(query) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise(resolve => rl.question(query, ans => {
+    rl.close();
+    resolve(ans);
+  }));
+}
+
+
+async function debugLogin() {
+  console.log('🔍 LinkedIn Login Debugger');
+  console.log('==========================\n');
+
+  if (!fs.existsSync(SCREENSHOT_DIR)) {
+    fs.mkdirSync(SCREENSHOT_DIR, { recursive: true });
+  }
+
+  // Launch with maximum stealth
+  const browser = await chromium.launch({
+    headless: false,
+    executablePath: '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+    args: [
+      '--disable-blink-features=AutomationControlled',
+      '--disable-web-security',
+      '--disable-features=IsolateOrigins,site-per-process',
+    ]
+  });
+
+  const context = await browser.newContext({
+    viewport: { width: 1920, height: 1080 },
+    userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0',
+    locale: 'en-US',
+    timezoneId: 'America/New_York',
+    permissions: ['notifications'],
+    colorScheme: 'light',
+  });
+
+  // Inject stealth script
+  await context.addInitScript(() => {
+    Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+    Object.defineProperty(navigator, 'plugins', { get: () => [1, 2, 3, 4, 5] });
+    Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] });
+    window.chrome = { runtime: {} };
+  });
+
+  const page = await context.newPage();
+
+  try {
+    console.log('1️⃣ Going to LinkedIn login page...');
+    await page.goto('https://www.linkedin.com/login', { 
+      waitUntil: 'networkidle',
+      timeout: 60000 
+    });
+    
+    await page.waitForTimeout(3000);
+    await page.screenshot({ path: path.join(SCREENSHOT_DIR, '01-login-page.png') });
+    console.log('   📸 Screenshot saved: 01-login-page.png');
+
+    console.log('\n2️⃣ Filling email...');
+    await page.fill('input#username', '628552@qq.com', { delay: 100 });
+    await page.waitForTimeout(1000);
+    
+    console.log('3️⃣ Prompting for password...');
+    const password = await askQuestion('Enter your LinkedIn password: ');
+    console.log('   (Password received, filling form...)');
+    await page.fill('input#password', password, { delay: 100 });
+    await page.fill('input#password', process.env.LINKEDIN_PASSWORD || '', { delay: 100 });
+    await page.waitForTimeout(1000);
+
+    console.log('4️⃣ Clicking submit...');
+    await page.click('button[type="submit"]');
+    
+    console.log('5️⃣ Waiting for navigation...');
+    await page.waitForTimeout(5000);
+    
+    await page.screenshot({ path: path.join(SCREENSHOT_DIR, '02-after-submit.png') });
+    console.log('   📸 Screenshot saved: 02-after-submit.png');
+
+    // Check current URL
+    const currentUrl = page.url();
+    console.log(`\n📍 Current URL: ${currentUrl}`);
+
+    // Check if we're on 2FA page
+    const has2FA = await page.$('input#input__phone_verification_pin') !== null;
+    const hasCaptcha = await page.$('[data-testid="captcha-internal"]') !== null || 
+                       await page.$('.captcha') !== null ||
+                       await page.$('text=Security verification') !== null;
+    
+    if (hasCaptcha) {
+      console.log('\n🚨 CAPTCHA DETECTED!');
+      console.log('   LinkedIn is showing a security challenge.');
+      console.log('   You need to manually solve it in the browser window.');
+      await page.screenshot({ path: path.join(SCREENSHOT_DIR, '03-captcha.png') });
+      
+      console.log('\n⏳ Waiting 60 seconds for you to solve CAPTCHA...');
+      await page.waitForTimeout(60000);
+    }
+
+    if (has2FA) {
+      console.log('\n🔐 2FA Prompt Detected');
+      console.log('   Please enter the 6-digit code from Microsoft Authenticator');
+      
+      // Wait for manual 2FA entry
+      await page.waitForTimeout(15000);
+      
+      await page.screenshot({ path: path.join(SCREENSHOT_DIR, '03-2fa.png') });
+      console.log('   📸 Screenshot saved: 03-2fa.png');
+    }
+
+    // Check if we're logged in
+    const isLoggedIn = await page.$('header.global-nav') !== null ||
+                       await page.$('[data-testid="global-nav"]') !== null;
+    
+    if (isLoggedIn) {
+      console.log('\n✅ SUCCESSFULLY LOGGED IN!');
+      
+      // Save session
+      const cookies = await context.cookies();
+      const sessionData = {
+        cookies,
+        timestamp: Date.now(),
+        userAgent: await page.evaluate(() => navigator.userAgent)
+      };
+
+      // Encrypt and save (simplified)
+      const sessionFile = path.join(CONFIG_DIR, 'sessions', 'linkedin-session.json');
+      fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+      
+      // Use same encryption as CLI
+      const crypto = require('crypto');
+      const machineData = [process.env.USER, process.env.HOME, process.platform].join('|');
+      const salt = crypto.randomBytes(32);
+      const key = crypto.pbkdf2Sync(machineData, salt, 100000, 32, 'sha256');
+      const iv = crypto.randomBytes(16);
+      const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+      const encrypted = Buffer.concat([cipher.update(JSON.stringify(sessionData)), cipher.final()]);
+      const tag = cipher.getAuthTag();
+      
+      fs.writeFileSync(sessionFile, JSON.stringify({
+        encrypted: encrypted.toString('base64'),
+        iv: iv.toString('base64'),
+        salt: salt.toString('base64'),
+        tag: tag.toString('base64')
+      }, null, 2));
+      
+      console.log(`   💾 Session saved to: ${sessionFile}`);
+      
+      // Test feed access
+      console.log('\n6️⃣ Testing feed access...');
+      await page.goto('https://www.linkedin.com/feed/', { waitUntil: 'networkidle' });
+      await page.waitForTimeout(3000);
+      await page.screenshot({ path: path.join(SCREENSHOT_DIR, '04-feed.png') });
+      console.log('   📸 Screenshot saved: 04-feed.png');
+      console.log(`   📄 Page title: ${await page.title()}`);
+      
+    } else {
+      console.log('\n❌ Login verification failed');
+      await page.screenshot({ path: path.join(SCREENSHOT_DIR, '03-failed.png') });
+      console.log('   📸 Screenshot saved: 03-failed.png');
+      
+      // Get page content for debugging
+      const content = await page.content();
+      fs.writeFileSync(path.join(SCREENSHOT_DIR, 'page-content.html'), content);
+      console.log('   📝 Page HTML saved: page-content.html');
+    }
+
+    console.log(`\n📁 All debug files saved to: ${SCREENSHOT_DIR}`);
+    console.log('\nBrowser will stay open for 30 seconds...');
+    await page.waitForTimeout(30000);
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    await page.screenshot({ path: path.join(SCREENSHOT_DIR, 'error.png') });
+  }
+
+  await browser.close();
+}
+
+console.log('This script will help debug the LinkedIn login process.');
+console.log('It will open a visible browser and take screenshots at each step.\n');
+
+debugLogin().catch(console.error);