linkedin-automation-cli 1.0.0

package/import-cookies.js

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+/**
+ * Cookie Import Tool for LinkedIn CLI
+ * 
+ * This tool imports cookies from various sources into the CLI's encrypted storage.
+ * Works on macOS and Linux.
+ * 
+ * Usage:
+ *   node import-cookies.js --file cookies.json
+ *   node import-cookies.js --browser chrome
+ *   node import-cookies.js --browser safari
+ *   node import-cookies.js --browser edge
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const CONFIG_DIR = path.join(require('os').homedir(), '.linkedin-cli');
+const SESSION_FILE = path.join(CONFIG_DIR, 'session.enc');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+let sourceFile = null;
+let browser = null;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--file' || args[i] === '-f') {
+    sourceFile = args[i + 1];
+    i++;
+  } else if (args[i] === '--browser' || args[i] === '-b') {
+    browser = args[i + 1]?.toLowerCase();
+    i++;
+  } else if (args[i] === '--help' || args[i] === '-h') {
+    showHelp();
+    process.exit(0);
+  }
+}
+
+function showHelp() {
+  console.log(`
+Cookie Import Tool for LinkedIn CLI
+====================================
+
+Import cookies from various sources into the CLI's encrypted storage.
+
+USAGE:
+  node import-cookies.js [OPTIONS]
+
+OPTIONS:
+  --file, -f <path>      Import from a JSON/Netscape cookies file
+  --browser, -b <name>   Import directly from browser
+                         Supported: chrome, edge, safari, firefox
+  --help, -h             Show this help
+
+EXAMPLES:
+  # Import from file
+  node import-cookies.js --file ./linkedin_cookies.json
+
+  # Import from Chrome (macOS)
+  node import-cookies.js --browser chrome
+
+  # Import from Safari (macOS)
+  node import-cookies.js --browser safari
+
+SUPPORTED COOKIE FORMATS:
+  1. JSON format (EditThisCookie extension)
+     [{"name": "li_at", "value": "...", "domain": ".linkedin.com", ...}]
+
+  2. Netscape format
+     # Netscape HTTP Cookie File
+     .linkedin.com\tTRUE\t/\tFALSE\t1234567890\tli_at\t...
+
+  3. Direct browser extraction (macOS)
+     Automatically extracts from browser's cookie store
+
+SECURITY NOTES:
+  - Cookies are encrypted with AES-256-GCM
+  - Encryption key is machine-bound
+  - Original cookie files should be deleted after import
+`);
+}
+
+// Check if running on macOS
+function isMacOS() {
+  return process.platform === 'darwin';
+}
+
+// Check if running on Linux
+function isLinux() {
+  return process.platform === 'linux';
+}
+
+// Extract cookies from Chrome/Chromium on macOS
+function extractChromeCookies() {
+  const chromePath = path.join(
+    require('os').homedir(),
+    'Library/Application Support/Google/Chrome/Default/Cookies'
+  );
+  
+  if (!fs.existsSync(chromePath)) {
+    console.error('❌ Chrome cookies not found at:', chromePath);
+    return null;
+  }
+
+  console.log('🔍 Found Chrome cookies at:', chromePath);
+  
+  // Try to use sqlite3 to extract LinkedIn cookies
+  try {
+    const result = execSync(
+      `sqlite3 "${chromePath}" "SELECT name, value, host_key, path, expires_utc FROM cookies WHERE host_key LIKE '%linkedin.com%'" 2>/dev/null`,
+      { encoding: 'utf8' }
+    );
+    
+    if (!result.trim()) {
+      console.error('❌ No LinkedIn cookies found in Chrome');
+      return null;
+    }
+
+    const cookies = [];
+    const lines = result.trim().split('\n');
+    
+    for (const line of lines) {
+      const [name, value, domain, path, expires] = line.split('|');
+      if (name && value) {
+        cookies.push({
+          name: name.trim(),
+          value: value.trim(),
+          domain: domain.trim(),
+          path: path?.trim() || '/',
+          expires: expires ? parseInt(expires.trim()) / 1000000 - 11644473600 : undefined
+        });
+      }
+    }
+
+    return cookies;
+  } catch (error) {
+    console.error('❌ Failed to extract Chrome cookies:', error.message);
+    console.log('💡 Chrome might be running. Close Chrome and try again.');
+    return null;
+  }
+}
+
+// Extract cookies from Edge on macOS
+function extractEdgeCookies() {
+  const edgePath = path.join(
+    require('os').homedir(),
+    'Library/Application Support/Microsoft Edge/Default/Cookies'
+  );
+  
+  if (!fs.existsSync(edgePath)) {
+    console.error('❌ Edge cookies not found at:', edgePath);
+    return null;
+  }
+
+  console.log('🔍 Found Edge cookies at:', edgePath);
+  
+  try {
+    const result = execSync(
+      `sqlite3 "${edgePath}" "SELECT name, value, host_key, path, expires_utc FROM cookies WHERE host_key LIKE '%linkedin.com%'" 2>/dev/null`,
+      { encoding: 'utf8' }
+    );
+    
+    if (!result.trim()) {
+      console.error('❌ No LinkedIn cookies found in Edge');
+      return null;
+    }
+
+    const cookies = [];
+    const lines = result.trim().split('\n');
+    
+    for (const line of lines) {
+      const [name, value, domain, path, expires] = line.split('|');
+      if (name && value) {
+        cookies.push({
+          name: name.trim(),
+          value: value.trim(),
+          domain: domain.trim(),
+          path: path?.trim() || '/',
+          expires: expires ? parseInt(expires.trim()) / 1000000 - 11644473600 : undefined
+        });
+      }
+    }
+
+    return cookies;
+  } catch (error) {
+    console.error('❌ Failed to extract Edge cookies:', error.message);
+    console.log('💡 Edge might be running. Close Edge and try again.');
+    return null;
+  }
+}
+
+// Parse JSON cookie file (from EditThisCookie extension)
+function parseJSONCookies(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const cookies = JSON.parse(content);
+    
+    if (!Array.isArray(cookies)) {
+      throw new Error('Invalid format: expected array of cookies');
+    }
+
+    // Filter only LinkedIn cookies
+    return cookies.filter(cookie => 
+      cookie.domain?.includes('linkedin.com') ||
+      cookie.host?.includes('linkedin.com')
+    );
+  } catch (error) {
+    console.error('❌ Failed to parse JSON cookies:', error.message);
+    return null;
+  }
+}
+
+// Parse Netscape cookie file
+function parseNetscapeCookies(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+    const cookies = [];
+
+    for (const line of lines) {
+      // Skip comments and empty lines
+      if (line.startsWith('#') || !line.trim()) continue;
+
+      const parts = line.split('\t');
+      if (parts.length >= 7) {
+        const [domain, flag, path, secure, expiration, name, value] = parts;
+        
+        if (domain.includes('linkedin.com')) {
+          cookies.push({
+            name: name.trim(),
+            value: value.trim(),
+            domain: domain.trim(),
+            path: path.trim(),
+            secure: secure === 'TRUE',
+            expirationDate: expiration !== '0' ? parseInt(expiration) : undefined
+          });
+        }
+      }
+    }
+
+    return cookies;
+  } catch (error) {
+    console.error('❌ Failed to parse Netscape cookies:', error.message);
+    return null;
+  }
+}
+
+// Import cookies into CLI storage
+async function importCookies(cookies) {
+  if (!cookies || cookies.length === 0) {
+    console.error('❌ No cookies to import');
+    return false;
+  }
+
+  console.log(`\n📦 Found ${cookies.length} LinkedIn cookies:`);
+  cookies.forEach(cookie => {
+    console.log(`   - ${cookie.name} (${cookie.domain})`);
+  });
+
+  // Ensure config directory exists
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+
+  // Create session data structure
+  const sessionData = {
+    cookies: cookies,
+    timestamp: Date.now(),
+    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'
+  };
+
+  // Import the secure storage from the CLI
+  try {
+    // We need to use the CLI's encryption module
+    const { getSecureStorage } = require('./dist/core/storage');
+    const storage = getSecureStorage();
+    
+    storage.save('linkedin-session', JSON.stringify(sessionData));
+    
+    console.log('\n✅ Cookies imported successfully!');
+    console.log(`📁 Session saved to: ${SESSION_FILE}`);
+    console.log('\n🔒 Security notes:');
+    console.log('   - Cookies are encrypted with AES-256-GCM');
+    console.log('   - Encryption key is machine-bound');
+    console.log('   - Session expires in 24 hours');
+    console.log('\n📝 Next steps:');
+    console.log('   1. Test: node ./dist/index.js auth status');
+    console.log('   2. List messages: node ./dist/index.js messages list');
+    
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to import cookies:', error.message);
+    console.log('\n💡 Make sure the CLI is built: npm run build');
+    return false;
+  }
+}
+
+// Main function
+async function main() {
+  console.log('🍪 LinkedIn CLI Cookie Import Tool\n');
+
+  let cookies = null;
+
+  if (browser) {
+    console.log(`📱 Extracting cookies from ${browser}...\n`);
+    
+    if (!isMacOS()) {
+      console.error('❌ Direct browser extraction is currently only supported on macOS');
+      console.log('💡 On Linux, export cookies to a file first, then use --file option');
+      process.exit(1);
+    }
+
+    switch (browser) {
+      case 'chrome':
+      case 'chromium':
+        cookies = extractChromeCookies();
+        break;
+      case 'edge':
+        cookies = extractEdgeCookies();
+        break;
+      case 'safari':
+        console.error('❌ Safari cookie extraction is not supported (Safari uses encrypted cookie storage)');
+        console.log('💡 Use Chrome or Edge instead, or export cookies manually');
+        process.exit(1);
+      case 'firefox':
+        console.error('❌ Firefox cookie extraction is not yet implemented');
+        console.log('💡 Export cookies manually using an extension');
+        process.exit(1);
+      default:
+        console.error(`❌ Unknown browser: ${browser}`);
+        console.log('💡 Supported browsers: chrome, edge');
+        process.exit(1);
+    }
+  } else if (sourceFile) {
+    console.log(`📄 Importing cookies from file: ${sourceFile}\n`);
+    
+    if (!fs.existsSync(sourceFile)) {
+      console.error('❌ File not found:', sourceFile);
+      process.exit(1);
+    }
+
+    // Detect format based on extension
+    const ext = path.extname(sourceFile).toLowerCase();
+    
+    if (ext === '.json') {
+      cookies = parseJSONCookies(sourceFile);
+    } else {
+      // Try Netscape format
+      cookies = parseNetscapeCookies(sourceFile);
+    }
+  } else {
+    console.error('❌ No source specified');
+    console.log('💡 Use --file or --browser option');
+    console.log('   Run with --help for more information');
+    process.exit(1);
+  }
+
+  if (cookies && cookies.length > 0) {
+    const success = await importCookies(cookies);
+    process.exit(success ? 0 : 1);
+  } else {
+    console.error('\n❌ No LinkedIn cookies found');
+    console.log('\n💡 Troubleshooting:');
+    console.log('   1. Make sure you are logged into LinkedIn in your browser');
+    console.log('   2. Close the browser completely before extracting cookies');
+    console.log('   3. Try using a cookie export extension instead');
+    process.exit(1);
+  }
+}
+
+// Run main
+main().catch(error => {
+  console.error('❌ Unexpected error:', error.message);
+  process.exit(1);
+});

package/internal/cmd/actions.go

@@ -0,0 +1,123 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/thaddeus-git/linkedin-cli/internal/linkedin"
+	"github.com/thaddeus-git/linkedin-cli/internal/pinchtab"
+	"github.com/thaddeus-git/linkedin-cli/internal/ratelimit"
+)
+
+func ensureProfile() {
+	if profileName == "" {
+		exitWithError("Profile name is required (--profile or LINKEDIN_PROFILE)")
+	}
+}
+
+func sendConnectionAction(profileURL string, note string) {
+	cfg, err := getConfigManager()
+	if err != nil {
+		exitWithError("Failed to initialize config: %v", err)
+	}
+
+	limiter := ratelimit.NewLimiter(profileName, ratelimit.DefaultLimits(), cfg)
+	if err := limiter.CheckConnection(); err != nil {
+		exitWithError("Rate limit check failed: %v", err)
+	}
+
+	if dryRun {
+		fmt.Println("[dry-run] Would:")
+		fmt.Printf("  - Navigate to: %s\n", profileURL)
+		fmt.Println("  - Click Connect button")
+		if note != "" {
+			fmt.Printf("  - Type note: %s\n", note)
+		}
+		fmt.Println("  - Click Send")
+		return
+	}
+
+	client := pinchtab.NewClient(getPinchTabHost())
+	navigator := linkedin.NewNavigator(client)
+
+	fmt.Printf("Sending connection request to %s...\n", profileURL)
+	logVerbose("Using profile: %s", profileName)
+
+	logVerbose("Navigating to profile...")
+	if err := client.Navigate(profileURL); err != nil {
+		exitWithError("Failed to navigate: %v", err)
+	}
+
+	logVerbose("Clicking Connect button...")
+	if err := navigator.ClickConnect(); err != nil {
+		exitWithError("Failed to click connect: %v", err)
+	}
+
+	logVerbose("Sending connection request...")
+	if err := navigator.SendConnectionRequest(note); err != nil {
+		exitWithError("Failed to send request: %v", err)
+	}
+
+	if err := limiter.RecordConnection(); err != nil {
+		fmt.Printf("Warning: Failed to record connection: %v\n", err)
+	}
+
+	cfg.UpdateLastUsed(profileName)
+	fmt.Println("✓ Connection request sent successfully!")
+
+	delay := limiter.GetDelay()
+	logVerbose("Waiting %v before exiting...", delay)
+	limiter.Sleep()
+}
+
+func sendMessageAction(profileURL string, message string) {
+	cfg, err := getConfigManager()
+	if err != nil {
+		exitWithError("Failed to initialize config: %v", err)
+	}
+
+	limiter := ratelimit.NewLimiter(profileName, ratelimit.DefaultLimits(), cfg)
+	if err := limiter.CheckMessage(); err != nil {
+		exitWithError("Rate limit check failed: %v", err)
+	}
+
+	if dryRun {
+		fmt.Println("[dry-run] Would:")
+		fmt.Printf("  - Navigate to: %s\n", profileURL)
+		fmt.Println("  - Click Message button")
+		fmt.Printf("  - Type message: %s\n", message)
+		fmt.Println("  - Click Send")
+		return
+	}
+
+	client := pinchtab.NewClient(getPinchTabHost())
+	navigator := linkedin.NewNavigator(client)
+
+	fmt.Printf("Sending message to %s...\n", profileURL)
+	logVerbose("Using profile: %s", profileName)
+
+	logVerbose("Navigating to profile...")
+	if err := client.Navigate(profileURL); err != nil {
+		exitWithError("Failed to navigate: %v", err)
+	}
+
+	logVerbose("Opening message modal...")
+	if err := navigator.OpenMessageModal(); err != nil {
+		exitWithError("Failed to open message modal: %v", err)
+	}
+
+	logVerbose("Sending message...")
+	if err := navigator.SendMessage(message); err != nil {
+		exitWithError("Failed to send message: %v", err)
+	}
+
+	if err := limiter.RecordMessage(); err != nil {
+		fmt.Printf("Warning: Failed to record message: %v\n", err)
+	}
+
+	cfg.UpdateLastUsed(profileName)
+	fmt.Println("✓ Message sent successfully!")
+
+	delay := limiter.GetDelay()
+	logVerbose("Waiting %v before exiting...", delay)
+	limiter.Sleep()
+}

package/internal/cmd/auth.go

@@ -0,0 +1,108 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/config"
+	"github.com/thaddeus-git/linkedin-cli/internal/pinchtab"
+)
+
+func init() {
+	rootCmd.AddCommand(authCmd)
+}
+
+var authCmd = &cobra.Command{
+	Use:   "auth",
+	Short: "Authenticate a LinkedIn profile",
+	Long: `Authenticate a LinkedIn profile by logging in through PinchTab.
+
+This command will:
+1. Start a PinchTab browser instance
+2. Navigate to LinkedIn login page
+3. Wait for you to log in manually
+4. Save the session for future use
+
+Example:
+  linkedin auth --profile john
+`,
+	Run: runAuth,
+}
+
+func runAuth(cmd *cobra.Command, args []string) {
+	if profileName == "" {
+		exitWithError("Profile name is required (--profile or LINKEDIN_PROFILE)")
+	}
+
+	cfg, err := getConfigManager()
+	if err != nil {
+		exitWithError("Failed to initialize config: %v", err)
+	}
+
+	client := pinchtab.NewClient(getPinchTabHost())
+
+	fmt.Printf("Starting authentication for profile '%s'...\n", profileName)
+	logVerbose("Using PinchTab at %s", getPinchTabHost())
+
+	if dryRun {
+		fmt.Println("[dry-run] Would:")
+		fmt.Println("  - Navigate to https://linkedin.com/login")
+		fmt.Println("  - Wait for manual login")
+		fmt.Println("  - Save profile configuration")
+		return
+	}
+
+	fmt.Println("Navigating to LinkedIn login...")
+	if err := client.Navigate("https://linkedin.com/login"); err != nil {
+		exitWithError("Failed to navigate to LinkedIn: %v", err)
+	}
+
+	fmt.Print("\n========================================\n")
+	fmt.Println("A browser window should be visible.")
+	fmt.Println("Please log in to LinkedIn manually.")
+	fmt.Println("Press Enter when you're logged in...")
+	fmt.Print("========================================\n")
+
+	os.Stdin.Read(make([]byte, 1))
+
+	fmt.Println("\nVerifying login...")
+	text, err := client.GetText()
+	if err != nil {
+		exitWithError("Failed to get page text: %v", err)
+	}
+
+	if !containsAny(text.Text, []string{"Me", "Messaging", "Notifications", "My Network"}) {
+		fmt.Println("Warning: Could not verify login. Session may not be saved.")
+		fmt.Println("Please try logging in again.")
+		return
+	}
+
+	profile := &config.Profile{
+		Name:      profileName,
+		CreatedAt: time.Now(),
+		LastUsed:  time.Now(),
+	}
+
+	if err := cfg.SaveProfile(profile); err != nil {
+		exitWithError("Failed to save profile: %v", err)
+	}
+
+	fmt.Printf("\n✓ Profile '%s' authenticated successfully!\n", profileName)
+	fmt.Println("You can now use this profile for automation.")
+}
+
+func containsAny(text string, substrs []string) bool {
+	for _, substr := range substrs {
+		if contains(text, substr) {
+			return true
+		}
+	}
+	return false
+}
+
+func contains(text, substr string) bool {
+	return strings.Contains(text, substr)
+}

package/internal/cmd/connect.go

@@ -0,0 +1,42 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/linkedin"
+)
+
+var (
+	connectURL  string
+	connectNote string
+)
+
+func init() {
+	rootCmd.AddCommand(connectCmd)
+	connectCmd.Flags().StringVarP(&connectURL, "url", "u", "", "LinkedIn profile URL (required)")
+	connectCmd.Flags().StringVarP(&connectNote, "message", "m", "", "Connection request note (optional)")
+	connectCmd.MarkFlagRequired("url")
+}
+
+var connectCmd = &cobra.Command{
+	Use:   "connect",
+	Short: "Send a connection request",
+	Long: `Send a connection request to a LinkedIn profile.
+
+Examples:
+  linkedin connect --profile john --url linkedin.com/in/alice
+  linkedin connect --profile john --url linkedin.com/in/alice --message "Hi Alice, loved your post!"
+`,
+	Run: runConnect,
+}
+
+func runConnect(cmd *cobra.Command, args []string) {
+	ensureProfile()
+
+	// Validate URL
+	profileURL, err := linkedin.ValidateProfileURL(connectURL)
+	if err != nil {
+		exitWithError("Invalid URL: %v", err)
+	}
+
+	sendConnectionAction(profileURL, connectNote)
+}

package/internal/cmd/message.go

@@ -0,0 +1,44 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/linkedin"
+)
+
+var (
+	messageURL     string
+	messageContent string
+)
+
+func init() {
+	rootCmd.AddCommand(messageCmd)
+	messageCmd.Flags().StringVarP(&messageURL, "url", "u", "", "LinkedIn profile URL (required)")
+	messageCmd.Flags().StringVarP(&messageContent, "message", "m", "", "Message content (required)")
+	messageCmd.MarkFlagRequired("url")
+	messageCmd.MarkFlagRequired("message")
+}
+
+var messageCmd = &cobra.Command{
+	Use:   "message",
+	Short: "Send a direct message",
+	Long: `Send a direct message to a LinkedIn connection.
+
+You must already be connected with the recipient.
+
+Examples:
+  linkedin message --profile john --url linkedin.com/in/alice --message "Thanks for connecting!"
+`,
+	Run: runMessage,
+}
+
+func runMessage(cmd *cobra.Command, args []string) {
+	ensureProfile()
+
+	// Validate URL
+	profileURL, err := linkedin.ValidateProfileURL(messageURL)
+	if err != nil {
+		exitWithError("Invalid URL: %v", err)
+	}
+
+	sendMessageAction(profileURL, messageContent)
+}