coffeeinabit 0.0.54 → 0.0.55

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 coffeeinabit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Makefile

@@ -6,7 +6,7 @@ patch-and-publish:
 	@grep -q "//registry.npmjs.org/:_authToken=" ~/.npmrc || (echo "Error: No npm token found in ~/.npmrc" && exit 1)
 	@echo "Token found. Publishing..."
 	npm version patch
-	npm publish --access public || (echo "" && echo "❌ Publish failed! If you see a 2FA error:" && echo "   1. Go to: https://www.npmjs.com/settings/kate_yan/tokens" && echo "   2. Create a 'Granular Access Token'" && echo "   3. Enable 'Bypass 2FA' permission" && echo "   4. Update ~/.npmrc with: //registry.npmjs.org/:_authToken=YOUR_NEW_TOKEN" && exit 1)
+	npm publish --access public || (echo "" && echo "❌ Publish failed! If you see a 2FA error:" && echo "   1. Go to: https://www.npmjs.com/settings/<YOUR_NPM_USERNAME>/tokens" && echo "   2. Create a 'Granular Access Token'" && echo "   3. Enable 'Bypass 2FA' permission" && echo "   4. Update ~/.npmrc with: //registry.npmjs.org/:_authToken=YOUR_NEW_TOKEN" && exit 1)
 
 stop:
 	pm2 stop "npx coffeeinabit" && pm2 delete "npx coffeeinabit" && pkill -9 -f "npm exec coffeeinabit"; pkill -9 -f "npx.*coffeeinabit"; pkill -9 -f "node.*coffeeinabit"

package/README.md

@@ -0,0 +1,88 @@
+# coffeeinabit
+
+LinkedIn automation tool powered by Playwright. Runs as a local Express server with Socket.IO for real-time communication with a cloud backend.
+
+## Architecture
+
+```
+server.js                  Express + Socket.IO server
+  ├── cloud_auth.js        AWS Cognito authentication
+  ├── linkedin_automation.js   Orchestrates browser automation
+  ├── tools/               Individual automation actions
+  │   ├── send_linkedin_message.js
+  │   ├── send_connection_request.js
+  │   ├── get_new_engagers.js
+  │   ├── get_message_threads.js
+  │   ├── get_new_messages.js
+  │   ├── get_profile.js
+  │   ├── get_linkedin_search_results.js
+  │   ├── get_linkedin_updates.js
+  │   ├── get_daily_linkedin_connections.js
+  │   ├── comment_post.js
+  │   ├── like_post.js
+  │   └── ...
+  ├── routes/              Express route handlers
+  ├── socket/              Socket.IO event handlers
+  ├── middleware/           Auth middleware
+  ├── helpers/             Utilities (logging, version check, auto-start)
+  └── state/               Application state management
+```
+
+## Prerequisites
+
+- Node.js 18+
+- Playwright (installed automatically via `postinstall`)
+
+## Setup
+
+1. Clone the repository:
+   ```bash
+   git clone <repo-url>
+   cd win_app
+   ```
+
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Create a `.env` file:
+   ```env
+   PORT=323
+   ```
+
+4. Provide a Playwright storage state file (exported LinkedIn session):
+   ```bash
+   # Default path: ./context/storage_state.json
+   # Or set via environment variable:
+   export STORAGE_STATE_PATH=/path/to/your/storage_state.json
+   ```
+
+## Running
+
+```bash
+npm start
+```
+
+The server starts on `http://localhost:323` (or the port specified in `.env`).
+
+## Testing
+
+Test scripts are in `test/`. They use Playwright to run automation actions directly.
+
+```bash
+# Start a persistent browser server for tests
+node test/browser_server.js
+
+# Run individual test scripts (connects to the browser server)
+node test/test_get_new_engagers.js
+node test/test_get_message_threads.js
+node test/test_message_simple.js
+node test/test_send_message.js
+```
+
+Set `STORAGE_STATE_PATH` to point to your Playwright storage state file before running tests.
+
+## License
+
+MIT

package/linkedin_automation.js

@@ -16,7 +16,9 @@ import { executeGetNewMessages } from './tools/get_new_messages.js';
 import { executeGetLinkedInUpdates } from './tools/get_linkedin_updates.js';
 import { executeGetNewEngagers } from './tools/get_new_engagers.js';
 import { executeGetMessageThreads } from './tools/get_message_threads.js';
-import { safeGoto } from './tools/navigation.js';
+import { executeGetContentSearchPosts } from './tools/get_content_search_posts.js';
+import { executeGetProfileUsername } from './tools/get_profile_username.js';
+import { safeGoto, LinkedInAuthError } from './tools/navigation.js';
 import { humanLikeAmbientMove, resetHumanMouseState } from './tools/human_mouse.js';
 import { logger } from './helpers/logger.js';
 
@@ -1065,6 +1067,14 @@ export class LinkedInAutomation {
           logger.log('[LinkedInAutomation] Executing get_message_threads action...');
           result = await executeGetMessageThreads(this.page, action);
           break;
+        case 'get_content_search_posts':
+          logger.log('[LinkedInAutomation] Executing get_content_search_posts action...');
+          result = await executeGetContentSearchPosts(this.page, action);
+          break;
+        case 'get_profile_username':
+          logger.log('[LinkedInAutomation] Executing get_profile_username action...');
+          result = await executeGetProfileUsername(this.page, action);
+          break;
         default:
           logger.log('[LinkedInAutomation] Unknown action type:', action.action);
           result = { error: `Unknown action type: ${action.action}` };
@@ -1083,8 +1093,13 @@ export class LinkedInAutomation {
     } catch (error) {
       logger.error('[LinkedInAutomation] Error executing action:', action.action, 'Error:', error.message);
       logger.error('[LinkedInAutomation] Error stack:', error.stack);
-      
-      const errorResult = { 
+
+      if (error instanceof LinkedInAuthError) {
+        logger.error('[LinkedInAutomation] LinkedIn session expired, resetting to authenticating phase');
+        this.transitionToPhase(this.PHASE_AUTHENTICATING);
+      }
+
+      const errorResult = {
         error: error.message,
         error_stack: error.stack,
         action_logs: actionLogs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coffeeinabit",
-  "version": "0.0.54",
+  "version": "0.0.55",
   "description": "coffeeinabit app",
   "main": "server.js",
   "type": "module",
@@ -10,7 +10,7 @@
     "windows",
     "playwright"
   ],
-  "author": "Azam Alamov <azam.alamov@icloud.com>",
+  "author": "coffeeinabit",
   "license": "MIT",
   "bin": {
     "coffeeinabit": "./server.js"
@@ -22,7 +22,6 @@
   },
   "dependencies": {
     "axios": "^1.6.0",
-    "coffeeinabit": "^0.0.47",
     "dotenv": "^16.3.1",
     "express": "^4.18.2",
     "express-session": "^1.17.3",

package/test/browser_runner.js

@@ -7,7 +7,7 @@
 import { chromium } from 'playwright';
 
 const CONFIG = {
-    userDataPath: '/Users/kateyanchenka/Documents/coffeeinabit_context/storage_state_team_lamoom_com.json',
+    userDataPath: process.env.STORAGE_STATE_PATH || './context/storage_state.json',
     headless: false
 };
 

package/test/browser_server.js

@@ -9,7 +9,7 @@ import { chromium } from 'playwright';
 import fs from 'fs';
 
 const CONFIG = {
-    userDataPath: '/Users/kateyanchenka/Documents/coffeeinabit_context/storage_state_team_lamoom_com.json',
+    userDataPath: process.env.STORAGE_STATE_PATH || './context/storage_state.json',
     debugPort: 9222,
     stateFile: './browser_state.json'
 };

package/test/test_get_content_search_posts.js

@@ -0,0 +1,170 @@
+/**
+ * Test script for get_content_search_posts action
+ * Tests scraping LinkedIn content search results (posts about a topic)
+ *
+ * This is a DRY-RUN test — it only scrapes and logs, does NOT post any comments.
+ * The company_name parameter shows what would be passed to the backend for
+ * "commenting on behalf of company" flow.
+ *
+ * Usage: node test/test_get_content_search_posts.js [search_url]
+ */
+
+import { chromium } from 'playwright';
+import fs from 'fs';
+import { executeGetContentSearchPosts } from '../tools/get_content_search_posts.js';
+
+const CONFIG = {
+    userDataPath: process.env.STORAGE_STATE_PATH || './context/storage_state.json',
+    headless: false,
+    stateFile: './browser_state.json',
+    useExistingBrowser: true,
+    // Default content search URL for testing
+    searchUrl: process.argv[2] || 'https://www.linkedin.com/search/results/content/?keywords=AI%20SDR&origin=SWITCH_SEARCH_VERTICAL',
+    // Company name for "comment on behalf of company" flow
+    companyName: 'coffeeinabit'
+};
+
+let browser, context, page;
+
+async function connectToExistingBrowser() {
+    if (!CONFIG.useExistingBrowser) {
+        return false;
+    }
+
+    try {
+        if (!fs.existsSync(CONFIG.stateFile)) {
+            return false;
+        }
+
+        const state = JSON.parse(fs.readFileSync(CONFIG.stateFile, 'utf8'));
+
+        console.log('Connecting to existing browser...');
+        console.log(`   CDP Endpoint: ${state.cdpEndpoint}`);
+
+        browser = await chromium.connectOverCDP(state.cdpEndpoint);
+
+        const contexts = browser.contexts();
+        if (contexts.length === 0) {
+            console.log('No contexts in existing browser');
+            return false;
+        }
+
+        context = contexts[0];
+        const pages = context.pages();
+
+        if (pages.length === 0) {
+            console.log('No pages in existing browser');
+            return false;
+        }
+
+        page = pages[0];
+
+        console.log('Connected to existing browser!');
+        console.log(`   Pages open: ${pages.length}`);
+        return true;
+
+    } catch (error) {
+        console.log(`Could not connect to existing browser: ${error.message}`);
+        return false;
+    }
+}
+
+async function setupBrowser() {
+    const connected = await connectToExistingBrowser();
+
+    if (!connected) {
+        console.log('Launching new browser...');
+        browser = await chromium.launch({
+            headless: CONFIG.headless,
+            args: ['--no-sandbox']
+        });
+
+        context = await browser.newContext({
+            storageState: CONFIG.userDataPath,
+            viewport: { width: 1280, height: 720 }
+        });
+
+        page = await context.newPage();
+    }
+
+    console.log('Browser ready\n');
+}
+
+async function runTest() {
+    console.log('\n' + '='.repeat(70));
+    console.log('DRY-RUN: Testing get_content_search_posts action');
+    console.log(`Company: ${CONFIG.companyName} (comments would be on behalf of this company)`);
+    console.log('='.repeat(70) + '\n');
+
+    await setupBrowser();
+
+    // Create action object like the backend would send
+    // company_name is passed in parameters — backend uses it for LLM prompt context
+    const action = {
+        action: 'get_content_search_posts',
+        action_id: 'test_' + Date.now(),
+        parameters: {
+            url: CONFIG.searchUrl,
+            company_name: CONFIG.companyName
+        }
+    };
+
+    console.log(`Search URL: ${CONFIG.searchUrl}`);
+    console.log(`Company: ${CONFIG.companyName} (dry-run, no comments will be posted)\n`);
+    console.log('Executing get_content_search_posts...\n');
+
+    try {
+        const result = await executeGetContentSearchPosts(page, action);
+
+        console.log('\n' + '='.repeat(70));
+        console.log('DRY-RUN RESULTS (no comments posted)');
+        console.log('='.repeat(70));
+
+        console.log('Status:', result.status);
+        console.log('Action:', result.action);
+
+        if (result.status === 'success') {
+            console.log('\nSUCCESS!');
+            console.log(`\nStatistics:`);
+            console.log(`   Total posts scraped: ${result.result.postsCount}`);
+            console.log(`   Pages processed: ${result.result.pagesProcessed}`);
+            console.log(`   Search URL: ${result.result.url}`);
+            console.log(`   Company for comments: ${CONFIG.companyName}`);
+
+            if (result.result.posts.length > 0) {
+                console.log(`\nScraped posts (first 5):`);
+                result.result.posts.slice(0, 5).forEach((post, index) => {
+                    console.log(`\n   ${index + 1}. ${post.authorName || 'Unknown Author'} (@${post.authorUsername || '???'})`);
+                    console.log(`      Headline: ${post.authorHeadline || 'N/A'}`);
+                    console.log(`      Text: ${(post.postText || '').substring(0, 120)}...`);
+                    console.log(`      Reactions: ${post.reactionCount} | Comments: ${post.commentCount}`);
+                    console.log(`      URL: ${post.postUrl}`);
+                    console.log(`      [DRY-RUN] Would send to backend for ${CONFIG.companyName} comment generation`);
+                });
+
+                console.log(`\nFull results:`);
+                console.log(JSON.stringify(result.result, null, 2));
+            } else {
+                console.log('\n   No posts found for this search query');
+            }
+        } else {
+            console.log('\nFAILED');
+            console.log('Error:', result.result.error || 'Unknown error');
+        }
+
+        console.log('\n' + '='.repeat(70) + '\n');
+
+    } catch (error) {
+        console.error('\nTest failed with error:', error.message);
+        console.error('Stack trace:', error.stack);
+    }
+
+    console.log('DRY-RUN test complete. No comments were posted.\n');
+    process.exit(0);
+}
+
+// Run test
+runTest().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/test/test_get_message_threads.js

@@ -12,7 +12,7 @@ import { chromium } from 'playwright';
 import fs from 'fs';
 
 const CONFIG = {
-    userDataPath: '/Users/kateyanchenka/Documents/coffeeinabit_context/storage_state_team_lamoom_com.json',
+    userDataPath: process.env.STORAGE_STATE_PATH || './context/storage_state.json',
     headless: false,
     stateFile: './browser_state.json',
     useExistingBrowser: true

package/test/test_get_new_engagers.js

@@ -10,7 +10,7 @@ import fs from 'fs';
 import { executeGetNewEngagers } from './tools/get_new_engagers.js';
 
 const CONFIG = {
-    userDataPath: '/Users/kateyanchenka/Documents/coffeeinabit_context/storage_state_team_lamoom_com.json',
+    userDataPath: process.env.STORAGE_STATE_PATH || './context/storage_state.json',
     headless: false,
     stateFile: './browser_state.json',
     useExistingBrowser: true

package/test/test_message_simple.js

@@ -10,7 +10,7 @@ import fs from 'fs';
 import { sendMessageInConversation, openMessageWindow } from './tools/send_linkedin_message.js';
 
 const CONFIG = {
-    userDataPath: '/Users/kateyanchenka/Documents/coffeeinabit_context/storage_state_team_lamoom_com.json',
+    userDataPath: process.env.STORAGE_STATE_PATH || './context/storage_state.json',
     targetProfile: 'alena-borykava',
     headless: false,
     dryRun: true,

package/test/test_send_message.js

@@ -9,7 +9,7 @@ import { chromium } from 'playwright';
 
 // Configuration
 const CONFIG = {
-    userDataPath: '/Users/kateyanchenka/Documents/coffeeinabit_context/storage_state_team_lamoom_com.json',
+    userDataPath: process.env.STORAGE_STATE_PATH || './context/storage_state.json',
     targetProfile: 'alena-borykava',
     message: 'Hey, how are you?',
     headless: false,

package/tools/get_content_search_posts.js

@@ -0,0 +1,183 @@
+import { safeGoto } from './navigation.js';
+import { waitRandom } from './human_mouse.js';
+
+/**
+ * Scrape content posts from LinkedIn content search results page.
+ * Extracts post URL, text, author info, and engagement counts.
+ */
+export async function executeGetContentSearchPosts(page, action) {
+  const searchUrl = action.parameters?.url || action.url;
+
+  if (!searchUrl) {
+    throw new Error('Missing url for get_content_search_posts');
+  }
+
+  console.log('[ContentSearch] Navigating to content search URL:', searchUrl);
+
+  try {
+    await safeGoto(page, searchUrl, {
+      waitUntil: 'domcontentloaded',
+      timeout: Math.floor(Math.random() * 20000) + 15000
+    });
+  } catch (error) {
+    console.error('[ContentSearch] Navigation failed:', error.message);
+    return {
+      action: 'get_content_search_posts',
+      result: { posts: [], postsCount: 0, url: searchUrl, error: error.message },
+      status: 'failed'
+    };
+  }
+
+  await waitRandom(2000, 4000, page);
+
+  // Scroll to load more posts (LinkedIn lazy-loads content search results)
+  console.log('[ContentSearch] Scrolling to load posts...');
+  const scrollIterations = 6;
+  for (let i = 0; i < scrollIterations; i++) {
+    await page.evaluate(() => window.scrollBy(0, 800));
+    await waitRandom(1000, 2000, page);
+  }
+
+  // Scroll back to top before extracting
+  await page.evaluate(() => window.scrollTo(0, 0));
+  await waitRandom(500, 1000, page);
+
+  console.log('[ContentSearch] Extracting posts from page...');
+
+  const posts = await page.evaluate(() => {
+    const results = [];
+    const seen = new Set();
+
+    // LinkedIn content search uses various container selectors
+    const postContainers = document.querySelectorAll(
+      'div.feed-shared-update-v2, div[data-urn], li.reusable-search__result-container'
+    );
+
+    console.log(`[ContentSearch] Found ${postContainers.length} post containers`);
+
+    postContainers.forEach((container) => {
+      try {
+        // Extract post URL
+        let postUrl = '';
+        const activityLink = container.querySelector('a[href*="feed/update/urn"], a[href*="activity:"]');
+        if (activityLink) {
+          const href = activityLink.getAttribute('href');
+          postUrl = href.startsWith('http') ? href : `https://www.linkedin.com${href}`;
+          postUrl = postUrl.split('?')[0]; // Clean query params
+        }
+
+        // Also try data-urn attribute
+        if (!postUrl) {
+          const urn = container.getAttribute('data-urn');
+          if (urn) {
+            postUrl = `https://www.linkedin.com/feed/update/${urn}`;
+          }
+        }
+
+        // Skip if no URL or already seen
+        if (!postUrl || seen.has(postUrl)) return;
+        seen.add(postUrl);
+
+        // Extract post text
+        let postText = '';
+        const textEl = container.querySelector(
+          '.feed-shared-text, .break-words, .update-components-text, span[dir="ltr"]'
+        );
+        if (textEl) {
+          postText = textEl.innerText?.trim().substring(0, 500) || '';
+        }
+
+        // Extract author name
+        let authorName = '';
+        const authorNameEl = container.querySelector(
+          '.update-components-actor__name span[aria-hidden="true"], ' +
+          '.feed-shared-actor__name span[aria-hidden="true"], ' +
+          'span.feed-shared-actor__title span[aria-hidden="true"]'
+        );
+        if (authorNameEl) {
+          authorName = authorNameEl.innerText?.trim() || '';
+        }
+
+        // Extract author username from profile link
+        let authorUsername = '';
+        const profileLink = container.querySelector(
+          'a[href*="/in/"]'
+        );
+        if (profileLink) {
+          const profileHref = profileLink.getAttribute('href');
+          const match = profileHref.match(/\/in\/([^\/\?#]+)/);
+          if (match) {
+            authorUsername = match[1];
+          }
+        }
+
+        // Extract author headline
+        let authorHeadline = '';
+        const headlineEl = container.querySelector(
+          '.update-components-actor__description, ' +
+          '.feed-shared-actor__description, ' +
+          '.update-components-actor__subDescription'
+        );
+        if (headlineEl) {
+          authorHeadline = headlineEl.innerText?.trim().substring(0, 200) || '';
+        }
+
+        // Extract reaction count
+        let reactionCount = 0;
+        const reactionsEl = container.querySelector(
+          '.social-details-social-counts__reactions-count, ' +
+          'button[aria-label*="reaction"] span, ' +
+          'span.social-details-social-counts__reactions-count'
+        );
+        if (reactionsEl) {
+          const text = reactionsEl.innerText?.trim() || '0';
+          reactionCount = parseInt(text.replace(/,/g, ''), 10) || 0;
+        }
+
+        // Extract comment count
+        let commentCount = 0;
+        const commentsEl = container.querySelector(
+          'button[aria-label*="comment"] span, ' +
+          'a[aria-label*="comment"]'
+        );
+        if (commentsEl) {
+          const text = commentsEl.innerText?.trim() || '0';
+          const match = text.match(/(\d[\d,]*)/);
+          if (match) {
+            commentCount = parseInt(match[1].replace(/,/g, ''), 10) || 0;
+          }
+        }
+
+        // Only add if we have some meaningful data
+        if (postText || authorName || authorUsername) {
+          results.push({
+            postUrl,
+            postText,
+            authorName,
+            authorUsername,
+            authorHeadline,
+            reactionCount,
+            commentCount
+          });
+        }
+      } catch (error) {
+        console.error('[ContentSearch] Error parsing post container:', error.message);
+      }
+    });
+
+    return results;
+  });
+
+  console.log(`[ContentSearch] Extracted ${posts.length} posts`);
+
+  return {
+    action: 'get_content_search_posts',
+    result: {
+      posts,
+      postsCount: posts.length,
+      url: searchUrl,
+      pagesProcessed: 1
+    },
+    status: 'success'
+  };
+}

package/tools/get_new_messages.js

@@ -384,97 +384,47 @@ function filterAndOrganizeNewMessages(allMessageEntities, lastCheckedTimestamp)
 }
 
 /**
- * Build map of encoded URLs that need to be decoded
+ * Build map of uniq_user_ids from conversation participants
  */
-function buildEncodedUrlMap(newMessagesByConversation, conversationParticipantsMap) {
-  const encodedUrlMap = new Map();
+function buildUniqIdMap(newMessagesByConversation, conversationParticipantsMap) {
+  const uniqIdMap = new Map();
   for (const conversationId in newMessagesByConversation) {
-    const encodedUrl = conversationParticipantsMap.get(conversationId);
-    if (encodedUrl) {
-      encodedUrlMap.set(encodedUrl, null);
+    const uniqId = conversationParticipantsMap.get(conversationId);
+    if (uniqId) {
+      uniqIdMap.set(conversationId, uniqId);
     } else {
       console.log(`[GetNewMessages] No participant found for conversation:`, conversationId);
     }
   }
-  console.log('[GetNewMessages] Unique profiles to decode:', encodedUrlMap.size);
-  return encodedUrlMap;
-}
-
-/**
- * Decode encoded LinkedIn profile URLs by visiting them
- */
-async function decodeProfileUrls(page, encodedUrlMap) {
-  const decodedUrlMap = new Map();
-  const maxDecodeAttempts = Math.min(encodedUrlMap.size, 50);
-  let decodeCount = 0;
-  
-  for (const encodedUrl of encodedUrlMap.keys()) {
-    if (decodeCount >= maxDecodeAttempts) {
-      console.log(`[GetNewMessages] Reached max decode attempts (${maxDecodeAttempts}), skipping remaining profiles`);
-      break;
-    }
-    
-    try {
-      console.log(`[GetNewMessages] Decoding profile ${decodeCount + 1}/${encodedUrlMap.size}: ${encodedUrl}`);
-      
-      const decodePromise = safeGoto(page, `https://www.linkedin.com/in/${encodedUrl}`, {
-        waitUntil: 'domcontentloaded',
-        timeout: 30000
-      });
-      
-      const timeoutPromise = new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('Decode timeout')), 35000)
-      );
-      
-      await Promise.race([decodePromise, timeoutPromise]);
-      await page.waitForLoadState('domcontentloaded', { timeout: 10000 });
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      
-      const currentUrl = page.url();
-      const match = currentUrl.match(/linkedin\.com\/in\/([^\/\?]+)/);
-      if (match && match[1]) {
-        decodedUrlMap.set(encodedUrl, match[1]);
-        console.log(`[GetNewMessages] Successfully decoded: ${encodedUrl} -> ${match[1]}`);
-      } else {
-        console.log(`[GetNewMessages] Could not extract URL from: ${currentUrl}`);
-      }
-      decodeCount++;
-    } catch (error) {
-      console.error(`[GetNewMessages] Failed to decode URL ${encodedUrl}:`, error.message);
-      decodeCount++;
-      continue;
-    }
-  }
-  
-  return decodedUrlMap;
+  console.log('[GetNewMessages] Conversations with uniq_user_ids:', uniqIdMap.size);
+  return uniqIdMap;
 }
 
 /**
  * ⚠️ SENDING FUNCTIONALITY: Send messages to API endpoint
- * This is the core functionality for sending collected messages to the backend
+ * Uses raw uniq_user_id (ACoXXX) instead of decoded username
  */
-async function sendMessagesToApi(newMessagesByConversation, conversationParticipantsMap, decodedUrlMap, accessToken) {
+async function sendMessagesToApi(newMessagesByConversation, uniqIdMap, accessToken) {
   let sentCount = 0;
   let failedCount = 0;
   let totalToSend = 0;
 
   for (const conversationId in newMessagesByConversation) {
     const messages = newMessagesByConversation[conversationId];
-    const encodedUrl = conversationParticipantsMap.get(conversationId);
-    const linkedinUrl = encodedUrl ? decodedUrlMap.get(encodedUrl) : null;
+    const uniqUserId = uniqIdMap.get(conversationId);
 
-    if (!linkedinUrl) {
-      console.log(`[GetNewMessages] Skipping conversation ${conversationId} - could not find or decode other person's URL`);
+    if (!uniqUserId) {
+      console.log(`[GetNewMessages] Skipping conversation ${conversationId} - no uniq_user_id found`);
       continue;
     }
 
-    console.log(`[GetNewMessages] Sending ${messages.length} messages to ${linkedinUrl}`);
+    console.log(`[GetNewMessages] Sending ${messages.length} messages for uniq_user_id ${uniqUserId}`);
     totalToSend += messages.length;
 
     for (const msg of messages) {
       try {
         const payload = {
-          linkedin_url: linkedinUrl,
+          uniq_user_id: uniqUserId,
           message: msg.messageText,
           is_receipent: !msg.isSelf,
           timestamp: msg.deliveredAt
@@ -492,7 +442,7 @@ async function sendMessagesToApi(newMessagesByConversation, conversationParticip
         sentCount++;
       } catch (error) {
         failedCount++;
-        console.error(`[GetNewMessages] Failed to send message to ${linkedinUrl}: "${msg.messageText.substring(0, 50)}..."`);
+        console.error(`[GetNewMessages] Failed to send message for ${uniqUserId}: "${msg.messageText.substring(0, 50)}..."`);
         console.error(`[GetNewMessages] Error:`, error.message);
         if (error.response) {
           console.error(`[GetNewMessages] Response status:`, error.response.status);
@@ -571,11 +521,10 @@ export async function executeGetNewMessages(page, action, accessToken) {
 
     const { newMessages, newMessagesByConversation } = filterAndOrganizeNewMessages(allMessageEntities, lastCheckedTimestamp);
 
-    const encodedUrlMap = buildEncodedUrlMap(newMessagesByConversation, conversationParticipantsMap);
-    const decodedUrlMap = await decodeProfileUrls(page, encodedUrlMap);
-    
-    // ⚠️ SENDING FUNCTIONALITY: Send all collected messages to API
-    await sendMessagesToApi(newMessagesByConversation, conversationParticipantsMap, decodedUrlMap, accessToken);
+    const uniqIdMap = buildUniqIdMap(newMessagesByConversation, conversationParticipantsMap);
+
+    // ⚠️ SENDING FUNCTIONALITY: Send all collected messages to API with raw uniq_user_ids
+    await sendMessagesToApi(newMessagesByConversation, uniqIdMap, accessToken);
 
     return {
       newMessagesCount: newMessages.length,

package/tools/get_profile.js

@@ -213,18 +213,33 @@ export async function executeGetProfile(page, action) {
     // Navigate to profile page with verification
     await navigateToProfile(page, username);
 
-    // Double-check we are on the correct profile URL before extracting (avoid analyzing previous user's profile)
-    const expectedProfilePath = `/in/${username}`;
+    // Check if LinkedIn redirected us (e.g., ACoXXX -> real-username)
     const currentUrl = page.url();
+    const expectedProfilePath = `/in/${username}`;
+    let redirectedFrom = null;
+    let resolvedUsername = username;
+
     if (!currentUrl.includes(expectedProfilePath)) {
-      console.warn(`[GetProfile] URL mismatch before extraction: expected "${expectedProfilePath}", got ${currentUrl}. Re-navigating to profile.`);
-      await navigateToProfile(page, username);
-      const urlAfterRetry = page.url();
-      if (!urlAfterRetry.includes(expectedProfilePath)) {
-        throw new Error(`Profile page URL verification failed. Expected URL to contain "${expectedProfilePath}" but got ${urlAfterRetry}. Refusing to extract to avoid wrong profile.`);
+      const match = currentUrl.match(/\/in\/([^\/\?]+)/);
+      if (match && match[1]) {
+        redirectedFrom = username;
+        resolvedUsername = match[1];
+        console.log(`[GetProfile] Redirect detected: ${username} -> ${resolvedUsername}`);
+      } else {
+        console.warn(`[GetProfile] URL mismatch and could not extract username from ${currentUrl}. Re-navigating.`);
+        await navigateToProfile(page, username);
+        const urlAfterRetry = page.url();
+        const retryMatch = urlAfterRetry.match(/\/in\/([^\/\?]+)/);
+        if (retryMatch && retryMatch[1] && retryMatch[1] !== username) {
+          redirectedFrom = username;
+          resolvedUsername = retryMatch[1];
+          console.log(`[GetProfile] Redirect detected after retry: ${username} -> ${resolvedUsername}`);
+        } else if (!urlAfterRetry.includes(expectedProfilePath)) {
+          throw new Error(`Profile page URL verification failed. Expected URL to contain "${expectedProfilePath}" but got ${urlAfterRetry}. Refusing to extract to avoid wrong profile.`);
+        }
       }
     }
-    await verifyPageUrl(page, expectedProfilePath, 'Pre-extraction');
+    await verifyPageUrl(page, `/in/${resolvedUsername}`, 'Pre-extraction');
 
     // Scroll and extract profile data
     console.log('[GetProfile] Scrolling profile page to load content');
@@ -242,7 +257,7 @@ export async function executeGetProfile(page, action) {
     console.log('[GetProfile] Fetching recent activity');
     let recentPosts = {};
     try {
-      await navigateToRecentActivity(page, username);
+      await navigateToRecentActivity(page, resolvedUsername);
       
       console.log('[GetProfile] Scrolling recent activity page to load posts');
       await gentleScroll(page, 'down', { stepRange: [140, 260], pauseRange: [80, 160], maxIterations: 40 });
@@ -259,12 +274,18 @@ export async function executeGetProfile(page, action) {
       profileText += `\nPending connection status: ${hasPendingConnection ? 'pending' : 'not pending'}`;
     }
     console.log('[GetProfile] Profile data extraction completed successfully');
-    return {
+    const result = {
       profileText,
       recentPosts,
       moreButtonOptions,
       isFirstDegreeConnection,
+      username: resolvedUsername,
     };
+    if (redirectedFrom) {
+      result.redirectedFrom = redirectedFrom;
+      result.resolvedUsername = resolvedUsername;
+    }
+    return result;
 
   } catch (error) {
     console.error('[GetProfile] Fatal error during profile retrieval:', error.message);

package/tools/get_profile_username.js

@@ -0,0 +1,61 @@
+import { safeGoto } from './navigation.js';
+
+/**
+ * Lightweight action that resolves a profile_id (e.g. ACoXXX) to a
+ * human-readable username by navigating to the profile and capturing the redirect.
+ * No scrolling, no text extraction, no recent activity.
+ */
+export async function executeGetProfileUsername(page, action) {
+  if (!page) {
+    throw new Error('No page available');
+  }
+
+  const profileId = action.parameters?.username || action.parameters?.profile_id;
+  if (!profileId) {
+    throw new Error('Missing username/profile_id for get_profile_username');
+  }
+
+  if (profileId.startsWith('http://') || profileId.startsWith('https://')) {
+    console.error(`[GetProfileUsername] Received URL instead of profile_id: ${profileId}`);
+    return null;
+  }
+
+  console.log(`[GetProfileUsername] Resolving profile_id: ${profileId}`);
+
+  try {
+    const profileUrl = `https://www.linkedin.com/in/${profileId}`;
+    await safeGoto(page, profileUrl, {
+      waitUntil: 'domcontentloaded',
+      timeout: 60000
+    });
+
+    await page.waitForLoadState('domcontentloaded');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // Extract username from current URL after potential redirect
+    const currentUrl = page.url();
+    const match = currentUrl.match(/\/in\/([^\/\?]+)/);
+    const resolvedUsername = match ? match[1] : profileId;
+    const redirected = resolvedUsername !== profileId;
+
+    console.log(`[GetProfileUsername] Resolved: ${profileId} -> ${resolvedUsername} (redirected: ${redirected})`);
+
+    const result = {
+      profile_id: profileId,
+      username: resolvedUsername,
+      redirected
+    };
+
+    // Include fields compatible with backend's analyze_get_profile for put_mapping()
+    if (redirected) {
+      result.redirectedFrom = profileId;
+      result.resolvedUsername = resolvedUsername;
+    }
+
+    return result;
+
+  } catch (error) {
+    console.error('[GetProfileUsername] Error:', error.message);
+    throw error;
+  }
+}

package/tools/navigation.js

@@ -1,3 +1,14 @@
+export class LinkedInAuthError extends Error {
+  constructor(url) {
+    super(`LinkedIn session expired - redirected to login wall (${url})`);
+    this.name = 'LinkedInAuthError';
+  }
+}
+
+function isAuthwall(url) {
+  return url && (url.includes('/authwall') || url.includes('/login') || url.includes('/checkpoint'));
+}
+
 export async function safeGoto(page, url, options = {}) {
   if (!page) return;
   try {
@@ -24,7 +35,14 @@ export async function safeGoto(page, url, options = {}) {
 
     console.log('[Navigation] safeGoto navigating to:', targetHref);
     await page.goto(url, options);
+
+    // Check if LinkedIn redirected to authwall/login
+    const landedUrl = page.url();
+    if (!isAuthwall(targetHref) && isAuthwall(landedUrl)) {
+      throw new LinkedInAuthError(landedUrl);
+    }
   } catch (error) {
+    if (error instanceof LinkedInAuthError) throw error;
     console.error('[Navigation] safeGoto failed for url:', url, error);
     throw error;
   }