linkedin-automation-cli 1.0.0

package/scripts/show-linkedin-data.js

@@ -0,0 +1,173 @@
+const { chromium } = require('playwright');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+async function showLinkedInData() {
+  console.log('🎯 Fetching Your LinkedIn Data');
+  console.log('==============================\n');
+
+  // Decrypt session
+  const sessionFile = path.join(require('os').homedir(), '.linkedin-cli/sessions/linkedin-session.json');
+  const encrypted = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+  
+  const machineData = [process.env.USER, process.env.HOME, 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 session = JSON.parse(Buffer.concat([decipher.update(encryptedData), decipher.final()]).toString());
+  
+  console.log('✅ Session decrypted successfully');
+  console.log(`📅 Session created: ${new Date(session.timestamp).toLocaleString()}`);
+  console.log(`🍪 Cookies: ${session.cookies.length} LinkedIn cookies loaded\n`);
+
+  // Launch Edge browser
+  console.log('🌐 Opening browser...');
+  const browser = await chromium.launch({ 
+    headless: true,
+    executablePath: '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge'
+  });
+  
+  const context = await browser.newContext({
+    userAgent: session.userAgent
+  });
+  
+  // Set cookies
+  await context.addCookies(session.cookies.map(c => ({
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path || '/',
+    secure: c.secure,
+    httpOnly: false,
+    sameSite: 'Lax'
+  })));
+  
+  // Check Feed
+  console.log('\n📰 CHECKING LINKEDIN FEED...');
+  console.log('─────────────────────────────────────');
+  const feedPage = await context.newPage();
+  await feedPage.goto('https://www.linkedin.com/feed/', { waitUntil: 'networkidle', timeout: 30000 });
+  
+  // Wait for feed to load
+  await feedPage.waitForTimeout(5000);
+  
+  // Get feed posts (try multiple selectors)
+  const posts = await feedPage.evaluate(() => {
+    const selectors = [
+      '.feed-shared-update-v2',
+      '[data-testid="feed-shared-update-v2"]',
+      '.scaffold-finite-scroll__content > div',
+      '[class*="update-v2"]'
+    ];
+    
+    for (const selector of selectors) {
+      const elements = document.querySelectorAll(selector);
+      if (elements.length > 0) {
+        return Array.from(elements).slice(0, 3).map(el => {
+          const authorEl = el.querySelector('[class*="actor"], [class*="author"], [class*="name"]');
+          const textEl = el.querySelector('[class*="update-text"], [class*="content"], p');
+          return {
+            author: authorEl?.innerText?.trim() || 'Unknown',
+            text: textEl?.innerText?.trim()?.substring(0, 150) || 'No text'
+          };
+        });
+      }
+    }
+    return [];
+  });
+  
+  if (posts.length > 0) {
+    console.log(`✅ Found ${posts.length} posts in your feed:\n`);
+    posts.forEach((post, i) => {
+      console.log(`${i + 1}. 👤 ${post.author}`);
+      console.log(`   📝 ${post.text}...\n`);
+    });
+  } else {
+    console.log('⚠️ Could not extract feed posts');
+  }
+  
+  // Check Messages
+  console.log('\n💬 CHECKING PRIVATE MESSAGES...');
+  console.log('─────────────────────────────────────');
+  const msgPage = await context.newPage();
+  await msgPage.goto('https://www.linkedin.com/messaging/', { waitUntil: 'networkidle', timeout: 30000 });
+  
+  await msgPage.waitForTimeout(5000);
+  
+  // Get conversations
+  const conversations = await msgPage.evaluate(() => {
+    const selectors = [
+      '.msg-conversation-card',
+      '[data-testid="conversation-card"]',
+      '[class*="conversation-card"]',
+      '[class*="msg-conversation-listitem"]'
+    ];
+    
+    for (const selector of selectors) {
+      const elements = document.querySelectorAll(selector);
+      if (elements.length > 0) {
+        return Array.from(elements).slice(0, 5).map(el => {
+          const nameSelectors = ['[class*="participant"]', '[class*="name"]', 'h3', 'span'];
+          const previewSelectors = ['[class*="preview"]', '[class*="message"]', 'p'];
+          
+          let name = 'Unknown';
+          let preview = '';
+          
+          for (const ns of nameSelectors) {
+            const ne = el.querySelector(ns);
+            if (ne?.innerText?.trim()) {
+              name = ne.innerText.trim();
+              break;
+            }
+          }
+          
+          for (const ps of previewSelectors) {
+            const pe = el.querySelector(ps);
+            if (pe?.innerText?.trim()) {
+              preview = pe.innerText.trim();
+              break;
+            }
+          }
+          
+          const isUnread = el.querySelector('[class*="unread"]') !== null;
+          
+          return { name, preview: preview?.substring(0, 100), isUnread };
+        });
+      }
+    }
+    return [];
+  });
+  
+  if (conversations.length > 0) {
+    console.log(`✅ Found ${conversations.length} conversations:\n`);
+    conversations.forEach((conv, i) => {
+      const unreadBadge = conv.isUnread ? ' 🔴 UNREAD' : '';
+      console.log(`${i + 1}. 👤 ${conv.name}${unreadBadge}`);
+      if (conv.preview) {
+        console.log(`   💬 ${conv.preview}...\n`);
+      }
+    });
+  } else {
+    console.log('⚠️ No conversations found');
+    console.log('   (LinkedIn might have changed their page structure)');
+  }
+  
+  await browser.close();
+  
+  console.log('\n✅ DONE!');
+  console.log('═════════════════════════════════════');
+  console.log('Your LinkedIn CLI is WORKING! 🎉');
+  console.log('═════════════════════════════════════');
+}
+
+showLinkedInData().catch(error => {
+  console.error('❌ Error:', error.message);
+  console.error(error.stack);
+  process.exit(1);
+});

package/src/agent/action-executor.test.ts

@@ -0,0 +1,464 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ActionExecutor, createActionExecutor } from './action-executor';
+import type { Page } from 'playwright';
+import type {
+  DOMRepresentation,
+  Action,
+  ClickAction,
+  TypeAction,
+  WaitAction,
+  NavigateAction,
+} from './types';
+
+describe('ActionExecutor', () => {
+  let mockPage: Page;
+  let mockDOM: DOMRepresentation;
+  let executor: ActionExecutor;
+
+  beforeEach(() => {
+    // Create mock Page
+    mockPage = {
+      url: vi.fn().mockReturnValue('https://linkedin.com/in/test-user'),
+      title: vi.fn().mockResolvedValue('Test User - LinkedIn'),
+      mouse: {
+        click: vi.fn().mockResolvedValue(undefined),
+      },
+      keyboard: {
+        type: vi.fn().mockResolvedValue(undefined),
+      },
+      waitForTimeout: vi.fn().mockResolvedValue(undefined),
+      goto: vi.fn().mockResolvedValue(undefined),
+    } as unknown as Page;
+
+    // Create mock DOM representation
+    mockDOM = {
+      url: 'https://linkedin.com/in/test-user',
+      title: 'Test User - LinkedIn',
+      elements: [
+        {
+          id: 'btn-connect',
+          tag: 'button',
+          role: 'button',
+          ariaLabel: 'Connect',
+          text: 'Connect',
+          visible: true,
+          enabled: true,
+          bbox: { x: 100, y: 200, width: 120, height: 40 },
+        },
+        {
+          id: 'input-message',
+          tag: 'textarea',
+          role: 'textbox',
+          text: '',
+          visible: true,
+          enabled: true,
+          bbox: { x: 50, y: 300, width: 400, height: 100 },
+        },
+        {
+          id: 'btn-submit',
+          tag: 'button',
+          text: 'Submit',
+          visible: true,
+          enabled: true,
+          bbox: { x: 200, y: 420, width: 80, height: 35 },
+        },
+      ],
+      metadata: {
+        pageType: 'profile',
+        profileName: 'Test User',
+        connectionState: 'not_connected',
+      },
+    };
+
+    executor = new ActionExecutor(mockPage, mockDOM);
+  });
+
+  describe('constructor', () => {
+    it('should create an ActionExecutor with page and DOM', () => {
+      const executor = new ActionExecutor(mockPage, mockDOM);
+      expect(executor).toBeInstanceOf(ActionExecutor);
+    });
+
+    it('should create via factory function', () => {
+      const executor = createActionExecutor(mockPage, mockDOM);
+      expect(executor).toBeInstanceOf(ActionExecutor);
+    });
+  });
+
+  describe('execute - click action', () => {
+    it('should execute click action with correct coordinates', async () => {
+      const action: ClickAction = {
+        type: 'click',
+        elementId: 'btn-connect',
+        description: 'Click connect button',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+
+      // Verify click was called with center coordinates
+      // centerX = 100 + 120/2 = 160, centerY = 200 + 40/2 = 220
+      expect(mockPage.mouse.click).toHaveBeenCalledWith(160, 220);
+    });
+
+    it('should handle click on element with different bbox', async () => {
+      const action: ClickAction = {
+        type: 'click',
+        elementId: 'btn-submit',
+        description: 'Click submit button',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      // centerX = 200 + 80/2 = 240, centerY = 420 + 35/2 = 437.5
+      expect(mockPage.mouse.click).toHaveBeenCalledWith(240, 437.5);
+    });
+
+    it('should return error when element not found', async () => {
+      const action: ClickAction = {
+        type: 'click',
+        elementId: 'non-existent-id',
+        description: 'Click non-existent button',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Element not found');
+      expect(result.error).toContain('non-existent-id');
+      expect(mockPage.mouse.click).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('execute - type action', () => {
+    it('should execute type action by clicking then typing', async () => {
+      const action: TypeAction = {
+        type: 'type',
+        elementId: 'input-message',
+        text: 'Hello, this is a test message',
+        description: 'Type message in textarea',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+
+      // Should click to focus first
+      // centerX = 50 + 400/2 = 250, centerY = 300 + 100/2 = 350
+      expect(mockPage.mouse.click).toHaveBeenCalledWith(250, 350);
+
+      // Should wait 100ms for focus
+      expect(mockPage.waitForTimeout).toHaveBeenCalledWith(100);
+
+      // Should type the text
+      expect(mockPage.keyboard.type).toHaveBeenCalledWith('Hello, this is a test message');
+    });
+
+    it('should handle empty text', async () => {
+      const action: TypeAction = {
+        type: 'type',
+        elementId: 'input-message',
+        text: '',
+        description: 'Type empty string',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPage.keyboard.type).toHaveBeenCalledWith('');
+    });
+
+    it('should return error when element not found for type action', async () => {
+      const action: TypeAction = {
+        type: 'type',
+        elementId: 'non-existent-input',
+        text: 'Some text',
+        description: 'Type in non-existent field',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Element not found');
+      expect(mockPage.mouse.click).not.toHaveBeenCalled();
+      expect(mockPage.keyboard.type).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('execute - wait action', () => {
+    it('should execute wait action with specified duration', async () => {
+      const action: WaitAction = {
+        type: 'wait',
+        durationMs: 2000,
+        description: 'Wait for modal to appear',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPage.waitForTimeout).toHaveBeenCalledWith(2000);
+    });
+
+    it('should handle zero duration wait', async () => {
+      const action: WaitAction = {
+        type: 'wait',
+        durationMs: 0,
+        description: 'Wait 0ms',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPage.waitForTimeout).toHaveBeenCalledWith(0);
+    });
+
+    it('should handle short duration wait', async () => {
+      const action: WaitAction = {
+        type: 'wait',
+        durationMs: 100,
+        description: 'Wait 100ms',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPage.waitForTimeout).toHaveBeenCalledWith(100);
+    });
+  });
+
+  describe('execute - navigate action', () => {
+    it('should execute navigate action with correct options', async () => {
+      const action: NavigateAction = {
+        type: 'navigate',
+        url: 'https://linkedin.com/in/another-user',
+        description: 'Navigate to another profile',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPage.goto).toHaveBeenCalledWith('https://linkedin.com/in/another-user', {
+        waitUntil: 'domcontentloaded',
+        timeout: 30000,
+      });
+    });
+
+    it('should handle navigation to root URL', async () => {
+      const action: NavigateAction = {
+        type: 'navigate',
+        url: 'https://linkedin.com',
+        description: 'Navigate to LinkedIn home',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPage.goto).toHaveBeenCalledWith('https://linkedin.com', {
+        waitUntil: 'domcontentloaded',
+        timeout: 30000,
+      });
+    });
+  });
+
+  describe('execute - unknown action type', () => {
+    it('should return error for unknown action type', async () => {
+      const action = {
+        type: 'unknown' as const,
+        description: 'Unknown action',
+      } as unknown as Action;
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Unknown action type');
+    });
+  });
+
+  describe('execute - error handling', () => {
+    it('should handle mouse click errors', async () => {
+      const errorMessage = 'Element not interactable';
+      vi.mocked(mockPage.mouse.click).mockRejectedValueOnce(new Error(errorMessage));
+
+      const action: ClickAction = {
+        type: 'click',
+        elementId: 'btn-connect',
+        description: 'Click button',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe(errorMessage);
+    });
+
+    it('should handle keyboard type errors', async () => {
+      const errorMessage = 'Element is not focused';
+      vi.mocked(mockPage.keyboard.type).mockRejectedValueOnce(new Error(errorMessage));
+
+      const action: TypeAction = {
+        type: 'type',
+        elementId: 'input-message',
+        text: 'Test',
+        description: 'Type text',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe(errorMessage);
+    });
+
+    it('should handle navigation errors', async () => {
+      const errorMessage = 'net::ERR_NAME_NOT_RESOLVED';
+      vi.mocked(mockPage.goto).mockRejectedValueOnce(new Error(errorMessage));
+
+      const action: NavigateAction = {
+        type: 'navigate',
+        url: 'https://invalid-url',
+        description: 'Navigate to invalid URL',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe(errorMessage);
+    });
+
+    it('should handle non-Error exceptions', async () => {
+      vi.mocked(mockPage.mouse.click).mockRejectedValueOnce('String error');
+
+      const action: ClickAction = {
+        type: 'click',
+        elementId: 'btn-connect',
+        description: 'Click button',
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('String error');
+    });
+  });
+
+  describe('executeAll', () => {
+    it('should execute multiple actions sequentially', async () => {
+      const actions: Action[] = [
+        { type: 'click', elementId: 'btn-connect', description: 'Click connect' },
+        { type: 'wait', durationMs: 1000, description: 'Wait for modal' },
+        { type: 'click', elementId: 'btn-submit', description: 'Click submit' },
+      ];
+
+      const results = await executor.executeAll(actions);
+
+      expect(results).toHaveLength(3);
+      expect(results[0].success).toBe(true);
+      expect(results[0].action.type).toBe('click');
+      expect(results[1].success).toBe(true);
+      expect(results[1].action.type).toBe('wait');
+      expect(results[2].success).toBe(true);
+      expect(results[2].action.type).toBe('click');
+
+      // Each result should have a timestamp
+      results.forEach((result) => {
+        expect(result.timestamp).toBeInstanceOf(Date);
+      });
+    });
+
+    it('should add 500ms delay between actions', async () => {
+      const actions: Action[] = [
+        { type: 'click', elementId: 'btn-connect', description: 'Click connect' },
+        { type: 'click', elementId: 'btn-submit', description: 'Click submit' },
+      ];
+
+      await executor.executeAll(actions);
+
+      // Should have waitForTimeout called for the 500ms delay between actions
+      // plus potentially 100ms for type actions (not in this test)
+      const waitCalls = vi.mocked(mockPage.waitForTimeout).mock.calls;
+      const hasDelay = waitCalls.some((call) => call[0] === 500);
+      expect(hasDelay).toBe(true);
+    });
+
+    it('should stop on first failure', async () => {
+      const actions: Action[] = [
+        { type: 'click', elementId: 'btn-connect', description: 'Click connect' },
+        { type: 'click', elementId: 'non-existent', description: 'Click non-existent' },
+        { type: 'click', elementId: 'btn-submit', description: 'Should not execute' },
+      ];
+
+      const results = await executor.executeAll(actions);
+
+      // Should only have 2 results (stopped after failure)
+      expect(results).toHaveLength(2);
+      expect(results[0].success).toBe(true);
+      expect(results[1].success).toBe(false);
+      expect(results[1].error).toContain('Element not found');
+
+      // Third action should not have been executed
+      expect(mockPage.mouse.click).toHaveBeenCalledTimes(1);
+    });
+
+    it('should log each action before execution', async () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      const actions: Action[] = [
+        { type: 'click', elementId: 'btn-connect', description: 'Click connect button' },
+      ];
+
+      await executor.executeAll(actions);
+
+      expect(consoleSpy).toHaveBeenCalledWith('Executing action: Click connect button');
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should log error when action fails', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const actions: Action[] = [
+        { type: 'click', elementId: 'non-existent', description: 'Click non-existent' },
+      ];
+
+      await executor.executeAll(actions);
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Action failed:'));
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should handle empty action array', async () => {
+      const results = await executor.executeAll([]);
+
+      expect(results).toHaveLength(0);
+    });
+
+    it('should handle single action', async () => {
+      const actions: Action[] = [{ type: 'wait', durationMs: 500, description: 'Wait briefly' }];
+
+      const results = await executor.executeAll(actions);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+
+      // No delay after the last action
+      const waitCalls = vi.mocked(mockPage.waitForTimeout).mock.calls;
+      expect(waitCalls).toHaveLength(1); // Only the wait action itself, no delay after
+    });
+
+    it('should include error in ExecutedAction when action fails', async () => {
+      const actions: Action[] = [
+        { type: 'click', elementId: 'non-existent', description: 'Click non-existent' },
+      ];
+
+      const results = await executor.executeAll(actions);
+
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toBeDefined();
+      expect(results[0].error).toContain('Element not found');
+      expect(results[0].timestamp).toBeInstanceOf(Date);
+    });
+  });
+});