fraim-framework 2.0.55 → 2.0.56

package/dist/registry/workflows/customer-development/linkedin-outreach.md

@@ -0,0 +1,593 @@
+# LinkedIn Outreach Workflow
+
+## INTENT
+To help founders and executives generate personalized LinkedIn outreach messages by researching profiles, identifying connection paths, finding conversation hooks, and combining them with the user's outreach intent.
+
+## PRINCIPLES
+- **Research First**: Thoroughly research each profile before generating messages
+- **Personalization**: Generate highly personalized messages based on profile research
+- **User Intent**: Understand and incorporate the user's specific outreach goal
+- **Connection Paths**: Identify direct connections or mutual connections who can help
+- **Rate Limiting**: Respect LinkedIn's terms of service with appropriate delays
+
+## WORKFLOW TRIGGER
+**User explicitly requests LinkedIn outreach help**:
+- "Generate LinkedIn messages for these profiles: [list of LinkedIn profile URLs]"
+- "Help me craft outreach messages for these people: [URLs]"
+- "Following the LinkedIn outreach workflow with these profiles: [URLs]"
+
+## INPUT REQUIREMENTS
+**User provides**:
+- List of LinkedIn profile URLs (one per line or comma-separated)
+- User's outreach intent (will be asked if not provided)
+
+**Example input**:
+```
+Profiles:
+https://linkedin.com/in/sarah-chen
+https://linkedin.com/in/michael-rodriguez
+https://linkedin.com/in/jane-smith
+
+Intent: I want to reach out to potential customers for our dev tools product
+```
+
+## AI AGENT PROCESS (Cursor)
+
+**CRITICAL**: Use Playwright MCP tools to interact with LinkedIn. Do NOT write hard-coded scripts with specific selectors. Use your intelligence to analyze what's on screen and interact accordingly.
+
+### Step 1: Parse Input
+**Cursor reads user input**:
+1. Extract LinkedIn profile URLs from user message
+2. Extract user's outreach intent (if provided)
+3. If intent not provided, ask user: "What is your goal in reaching out to these people? (e.g., 'Find potential customers', 'Build partnerships', 'Hire talent')"
+4. Validate that at least one profile URL is provided
+
+### Step 2: Browser Setup & Session Management
+**Use Playwright MCP to launch browser with session persistence**:
+1. **Navigate to LinkedIn**: Use `browser_navigate` to open LinkedIn (the browser extension maintains session state automatically)
+2. **Take snapshot**: Use `browser_snapshot` to see current state and verify if logged in
+3. **Check login status from snapshot**:
+   - If you see "Sign in" button → Not logged in
+   - If you see navigation menu with profile/notifications → Logged in
+   - If you see "Message" button on profiles → Logged in
+
+**Note**: The browser extension automatically maintains cookies and session state between sessions, so if the user logged in previously, they should remain logged in. No manual cookie management needed.
+
+### Step 3: LinkedIn Navigation & Authentication
+**Cursor navigates to LinkedIn**:
+1. Navigate to LinkedIn using `browser_navigate`
+2. Take a snapshot with `browser_snapshot` to see current state
+3. **Check login status**:
+   - Look for "Sign in" button → Not logged in
+   - Look for navigation menu with profile icon → Logged in
+   - Look for "Message" button on profiles → Logged in
+4. **If not logged in**:
+   - Navigate to login page using `browser_navigate`
+   - Inform user: "Please log in to LinkedIn in the browser window"
+   - Wait for user to manually log in
+   - Use `browser_wait_for` with text like "Home" or "Feed" to detect login success
+   - Take snapshot to verify login
+   - **Session is automatically saved** by the browser extension
+5. **If already logged in**: Proceed directly to profile research
+
+**CRITICAL**: 
+- Cursor does NOT automate login. User must log in manually to comply with LinkedIn ToS.
+- **The browser extension automatically maintains session state** - cookies are persisted between sessions
+- User only needs to log in once, and subsequent workflow runs will use the saved session
+
+### Step 4: Research Each Profile
+**For each profile URL, Cursor performs research using intelligent browser interaction**:
+
+#### 4a. Navigate to Profile
+1. Use `browser_navigate` to go to the profile URL
+2. Use `browser_wait_for` to wait for page to load
+3. Take a snapshot with `browser_snapshot` to see the profile page
+4. Analyze what's visible on screen
+
+#### 4b. Check Connection Status
+**Determine if direct connection or find mutual connections**:
+1. **Look at the snapshot** to identify connection status:
+   - If you see a "Message" button → Already connected
+   - If you see a "Connect" button → Not connected
+   - If you see text like "X mutual connections" → Has mutual connections
+2. **If mutual connections exist**:
+   - Click on the mutual connections indicator/text
+   - Wait for modal/dialog to appear (use `browser_wait_for`)
+   - Take snapshot to see mutual connection names
+   - Extract the names from the snapshot
+   - Close the modal (click X, press Escape, or click outside)
+3. **Store connection info**:
+   - Direct connection: "You are already connected"
+   - Mutual connections: "You have X mutual connection(s): [names]"
+   - No connection: "No direct or mutual connections found"
+
+#### 4c. Find Person's Interests and Hooks
+**Research what would be good conversation starters by analyzing the profile**:
+
+1. **Extract Basic Profile Info**:
+   - Look at the snapshot for the person's name (usually large heading at top)
+   - Find their headline/title (usually below name)
+   - Note their location if visible
+
+2. **Scroll Through Profile**:
+   - Use `browser_evaluate` to scroll down the page
+   - Take multiple snapshots as you scroll to see different sections
+   - Look for: About section, Experience, Education, Skills, Activity/Posts
+
+3. **Find Recent Activity/Posts**:
+   - Scroll to find their activity feed or recent posts
+   - Look for posts they've made (usually in a feed section)
+   - Extract the text/content of 2-3 most recent posts
+   - Note topics they're discussing
+
+4. **Extract Skills and Expertise**:
+   - Find the Skills section on their profile
+   - Extract skill names (usually listed items)
+   - Note top 5-10 skills
+
+5. **Extract Experience Highlights**:
+   - Find the Experience section
+   - Note current and previous roles
+   - Extract company names and role titles
+
+6. **Identify Hooks** (conversation starters):
+   - **Recent posts**: "Recent post about: [topic]"
+   - **Shared interests**: "Expertise in: [skills]"
+   - **Current role**: "Current role: [headline]"
+   - **Location**: "Based in: [location]"
+   - **Experience**: "Background: [notable roles/companies]"
+
+**IMPORTANT**: Use snapshots to see what's actually on screen. Don't assume specific CSS selectors exist. Analyze the visual layout and extract information accordingly.
+
+#### 4d. Store Research Results
+**For each profile, compile**:
+- Profile URL
+- Name
+- Headline/Title
+- Connection info (direct/mutual/none)
+- Hooks found (array of conversation starters)
+- Recent posts (if found)
+- Skills (if found)
+- Experience highlights (if found)
+
+### Step 5: Get User's Outreach Intent
+**If not already provided, ask user**:
+```
+I've researched [X] profile(s). Now I need to understand your outreach goal.
+
+What is your intent in reaching out to these people?
+Examples:
+- "I want to find potential customers for our dev tools product"
+- "I'm looking to build partnerships with companies in this space"
+- "I'm hiring and want to reach out to potential candidates"
+- "I want to learn from their experience in [topic]"
+
+Your intent:
+```
+
+Wait for user to provide their intent.
+
+### Step 6: Generate Personalized Messages
+**For each profile, combine research + user intent to create message**:
+
+Use your AI capabilities to generate a message with this prompt:
+
+```
+Generate a short, personalized LinkedIn connection request message (under 300 characters).
+
+Profile Research:
+- Name: [name]
+- Headline: [headline]
+- Connection: [connection info]
+- Hooks: [list of hooks found]
+
+User's Outreach Intent: [user intent]
+
+Requirements:
+1. Start with a personalized hook based on their profile (recent post, shared interest, mutual connection, etc.)
+2. Clearly state the user's intent
+3. Keep it under 300 characters
+4. Be genuine and not salesy
+5. If mutual connections exist, mention them naturally
+6. End with a clear call to action
+
+Message:
+```
+
+Generate one message per profile.
+
+### Step 7: Generate Introduction Messages for Mutual Connections
+**If mutual connections exist, generate messages to ask for introductions**:
+
+For each mutual connection, generate a message asking them to introduce you:
+
+```
+Generate a brief message (under 200 characters) asking [mutual connection name] to introduce you to [target name].
+
+Context:
+- You're reaching out to [target name] because: [user intent]
+- Your connection: [mutual connection name]
+- Why this introduction makes sense: [shared context, if any]
+
+Message should be:
+- Short and respectful
+- Clear about what you're asking
+- Explain why the introduction is valuable
+- Not pushy or demanding
+
+Message:
+```
+
+### Step 8: Save Research to File
+**Create a comprehensive research document**:
+
+Save all research to a markdown file: `docs/linkedin-outreach/[date]-[profile-name]-research.md`
+
+**File Structure**:
+```markdown
+# LinkedIn Outreach Research - [Date]
+
+## Target Profile: [Name]
+
+### Profile Information
+- **Name:** [name]
+- **Headline:** [headline]
+- **Location:** [location]
+- **Profile URL:** [URL]
+- **Connection Status:** [direct/mutual/none]
+
+### Connection Information
+- **Type:** [direct connection / mutual connections / no connection]
+- **Mutual Connections:** 
+  - [List all mutual connection names]
+  - [For each, note their relationship/context if available]
+
+### Research Findings
+
+#### Hooks Identified
+1. [Hook 1 - e.g., Recent post about...]
+2. [Hook 2 - e.g., Expertise in...]
+3. [Hook 3 - e.g., Current role...]
+
+#### Recent Activity
+- [Post 1 summary]
+- [Post 2 summary]
+- [Post 3 summary]
+
+#### Skills & Expertise
+- [Skill 1]
+- [Skill 2]
+- [Skill 3]
+...
+
+#### Experience Highlights
+- [Notable role/company 1]
+- [Notable role/company 2]
+...
+
+### Generated Messages
+
+#### Direct Connection Request Message
+**Length:** [X]/300 characters
+
+"[Generated message]"
+
+#### Introduction Request Messages (for Mutual Connections)
+
+**To [Mutual Connection 1 Name]:**
+"[Generated introduction request message]"
+
+**To [Mutual Connection 2 Name]:**
+"[Generated introduction request message]"
+
+...
+
+### Outreach Intent
+[User's stated intent]
+
+### Next Steps
+- [ ] Review and refine messages
+- [ ] Decide: Direct connection or ask for introduction?
+- [ ] Send connection request or introduction request
+- [ ] Follow up if no response after 1 week
+```
+
+### Step 9: Display Results & Offer Actions
+**Display all generated messages and offer to populate/send**:
+
+```
+✅ LinkedIn Outreach Research Complete
+
+📊 Profile: [Name] - [Headline]
+🔗 Profile URL: [URL]
+🤝 Connection: [connection info]
+
+🎣 Hooks Found:
+1. [Hook 1]
+2. [Hook 2]
+3. [Hook 3]
+
+💬 Generated Connection Request Message ([X]/300 characters):
+"[Message]"
+
+🤝 Mutual Connections Available:
+- [Name 1] - [Their role/context]
+- [Name 2] - [Their role/context]
+...
+
+💌 Introduction Request Messages:
+
+To [Mutual Connection 1]:
+"[Introduction message]"
+
+To [Mutual Connection 2]:
+"[Introduction message]"
+
+📄 Research saved to: docs/linkedin-outreach/[filename].md
+
+---
+
+🎯 What would you like to do next?
+
+1. **Populate message in LinkedIn** - I'll fill in the connection request form for you to review and send
+2. **Send connection request** - I'll send it on your behalf (requires confirmation)
+3. **Ask for introduction** - I'll help you message a mutual connection to request an introduction
+4. **Refine message** - Tell me what to change and I'll update it
+5. **Review research file** - Check the saved research document first
+
+Your choice:
+```
+
+**CRITICAL**: Always ask for user confirmation before sending any messages. Never send automatically without explicit user approval.
+
+### Step 10: Execute User's Choice
+
+#### Option 1: Populate Message in LinkedIn
+1. Navigate to the profile using `browser_navigate`
+2. Click "Connect" or "More actions" → "Connect"
+3. Click "Add a note"
+4. **CRITICAL - Properly type message into LinkedIn's message box:**
+   
+   **LinkedIn uses a contenteditable div for message input, not a regular textarea. The text must be properly inserted to activate the send button. Follow these steps:**
+   
+   a. **First, click/focus the message input box** using `browser_click` on the message input element
+   
+   b. **Clear any existing placeholder text** by:
+      - Using `browser_evaluate` to select all text (Ctrl+A / Cmd+A)
+      - Or using `browser_press_key` with "Control+a" (Windows) or "Meta+a" (Mac) to select all
+      - Then `browser_press_key` with "Backspace" or "Delete" to clear
+   
+   c. **Type the message using `browser_type`** with the `slowly: true` parameter:
+      ```
+      Use browser_type with:
+      - element: "LinkedIn message input box"
+      - ref: [the CSS selector or ref from snapshot]
+      - text: [the generated message]
+      - slowly: true  (IMPORTANT: This types character-by-character, which properly triggers LinkedIn's input detection)
+      ```
+   
+   d. **After typing, verify the text is visible** by taking a snapshot and checking that:
+      - The message text appears in the input box (not as placeholder)
+      - The text has actual styling (not placeholder gray text)
+      - The send button becomes enabled/active
+   
+   e. **If send button is still disabled**, try:
+      - Clicking the message box again to ensure focus
+      - Using `browser_evaluate` to trigger input events manually:
+        ```javascript
+        const messageBox = document.querySelector('.msg-form__contenteditable');
+        if (messageBox) {
+          messageBox.dispatchEvent(new InputEvent('input', { bubbles: true }));
+          messageBox.dispatchEvent(new Event('change', { bubbles: true }));
+        }
+        ```
+      - Wait 1-2 seconds for LinkedIn to process the input
+      - Check snapshot again to verify send button is enabled
+   
+   **Common mistakes to avoid:**
+   - ❌ Don't just set textContent/innerHTML - LinkedIn won't detect it
+   - ❌ Don't type too fast - use `slowly: true` to type character-by-character
+   - ❌ Don't skip clearing placeholder - old placeholder can blend with new text
+   - ❌ Don't forget to focus the input first - typing without focus won't work
+   
+5. **DO NOT click "Send"** - leave it for user to review and send
+6. Inform user: "Message populated in LinkedIn. Please review and click 'Send invitation' when ready."
+
+#### Option 2: Send Connection Request (with confirmation)
+1. Ask user: "Are you sure you want me to send this connection request now?"
+2. If confirmed:
+   - Navigate to profile
+   - Click "Connect" → "Add a note"
+   - **Fill in message using the same detailed process from Option 1** (clear placeholder, type slowly, verify send button activates)
+   - **Wait for send button to be enabled** - take snapshot to verify it's clickable
+   - Click "Send invitation" only after confirming the button is enabled
+   - Confirm: "✅ Connection request sent to [Name]"
+3. If not confirmed, proceed with Option 1 (populate only)
+
+#### Option 3: Ask for Introduction via Mutual Connection
+1. Ask user: "Which mutual connection would you like me to message for an introduction?"
+2. Navigate to that mutual connection's profile
+3. Click "Message"
+4. **Fill in the introduction request message using the same detailed process:**
+   - Click/focus the message input box
+   - Clear any placeholder text (select all + delete)
+   - Type message using `browser_type` with `slowly: true`
+   - Verify text is visible and send button is enabled
+   - If send button not enabled, follow troubleshooting steps from Option 1
+5. **DO NOT send automatically** - show message to user for review
+6. Ask: "Ready to send this introduction request? (Yes/No)"
+7. If yes, send (only after verifying send button is enabled); if no, allow editing
+
+#### Option 4: Refine Message
+1. Ask user: "What would you like to change about the message?"
+2. Generate new version based on feedback
+3. Update the research file
+4. Offer to populate in LinkedIn again
+
+#### Option 5: Review Research File
+1. Open the saved markdown file
+2. Display key sections
+3. Ask if user wants to proceed with any actions
+
+## OUTPUT TEMPLATE
+
+### Research File Template
+**File Location:** `docs/linkedin-outreach/[YYYY-MM-DD]-[profile-name-slug]-research.md`
+
+**Example filename:** `docs/linkedin-outreach/2025-01-15-dharmesh-shah-research.md`
+
+### Workflow Execution Summary
+**Display in Cursor chat**:
+```
+✅ LinkedIn Outreach Research Complete
+
+📊 Profile: 
+🔗 Profile URL: 
+🤝 Connection: 
+
+🎣 Hooks Found:
+
+💬 Generated Connection Request Message (298/300 characters):
+
+🤝 Mutual Connections Available:
+
+💌 Introduction Request Messages:
+
+📄 Research saved to: 
+
+---
+
+🎯 What would you like to do next?
+
+1. Populate message in LinkedIn - I'll fill in the connection request form for you to review and send
+2. Send connection request - I'll send it on your behalf (requires confirmation)
+3. Ask for introduction - I'll help you message a mutual connection to request an introduction
+4. Refine message - Tell me what to change and I'll update it
+5. Review research file - Check the saved research document first
+
+Your choice:
+```
+
+## EXAMPLES
+
+### Good: Complete Workflow Execution
+```
+User: "Generate LinkedIn messages for these profiles:
+https://linkedin.com/in/sarah-chen
+https://linkedin.com/in/michael-rodriguez
+
+My intent: I want to find potential customers for our dev tools product"
+
+Cursor Workflow:
+1. ✅ Parsed profile URLs
+2. ✅ Extracted user intent
+3. ✅ Launched browser
+4. ✅ User logged into LinkedIn
+5. ✅ Researched Sarah's profile:
+   - Found 2 mutual connections: John Doe, Jane Smith
+   - Found recent post about scaling infrastructure
+   - Identified expertise in distributed systems
+6. ✅ Researched Michael's profile:
+   - No connections found
+   - Found expertise in microservices
+7. ✅ Generated personalized messages combining hooks + intent
+8. ✅ Displayed results
+
+Output: 2 personalized messages ready for review
+```
+
+### Bad: Missing User Intent
+```
+User: "Generate messages for these profiles: [URLs]"
+
+Cursor Workflow:
+1. ✅ Parsed URLs
+2. ❌ No user intent provided
+3. ✅ Asked user for intent
+4. User provides: "Find customers"
+5. ✅ Continues with research and message generation
+
+Result: Workflow completes successfully after getting intent
+```
+
+### Bad: Invalid Profile URLs
+```
+User: "Generate messages for: invalid-url"
+
+Cursor Workflow:
+1. ❌ Invalid LinkedIn URL format
+2. ✅ Asks user: "Please provide valid LinkedIn profile URLs (format: https://linkedin.com/in/username)"
+3. User provides correct URLs
+4. ✅ Continues workflow
+
+Result: Workflow validates input and asks for correction
+```
+
+## SUCCESS METRICS
+- **Profile Research Accuracy**: 95% of extracted profile data is accurate
+- **Hook Identification**: At least one relevant hook found per profile
+- **Message Personalization**: Messages reference specific profile details
+- **Connection Path Identification**: Correctly identifies direct/mutual/no connections
+- **Time Efficiency**: User spends 2 minutes reviewing vs 30 minutes researching manually
+- **Message Quality**: Messages are under 300 characters and include both hook and intent
+
+## TECHNICAL REQUIREMENTS
+
+### Dependencies
+- Playwright (if user has not enabled this MCP, ask them to)
+- TypeScript
+- AI/LLM access (via Cursor's built-in AI or OpenAI API)
+
+### Browser Automation Best Practices
+- Use realistic delays between actions (1000-2000ms)
+- Randomize delays to avoid detection
+- Scroll pages naturally to load content
+- Respect rate limits (don't scrape too many profiles too quickly)
+- Never store LinkedIn credentials
+- Always wait for user to log in manually
+
+### Error Handling
+- If LinkedIn login fails: Ask user to log in manually
+- If profile URL is invalid: Skip and continue with next profile
+- If profile is private: Note that and use available public information
+- If scraping fails: Log error, continue with other profiles
+- If AI generation fails: Retry with simpler prompt
+
+## SECURITY & COMPLIANCE
+
+### LinkedIn Terms of Service
+- ✅ User must log in manually (no credential storage)
+- ✅ Respect rate limits (reasonable delays between profile visits)
+- ✅ Human-like behavior patterns
+- ✅ No mass automation or spamming
+- ✅ All messages are suggestions - user reviews before sending
+
+### Data Privacy
+- ✅ Profile data used only for message generation
+- ✅ No profile data stored permanently
+- ✅ User can review all research before messages are generated
+- ✅ Messages are suggestions - user has full control
+
+## WORKFLOW VARIATIONS
+
+### Variation 1: Batch Processing
+If user provides many profiles (10+), process in batches:
+1. Research first 5 profiles
+2. Generate messages for those 5
+3. Display results
+4. Ask user if they want to continue with remaining profiles
+
+### Variation 2: Interactive Refinement
+After generating messages:
+1. Display all messages
+2. Ask user: "Would you like to refine any messages?"
+3. For each message user wants to refine:
+   - Show current message
+   - Ask what to change
+   - Regenerate with new instructions
+
+### Variation 3: Export Messages
+After generation:
+1. Ask user: "Would you like to export these messages?"
+2. If yes, create a markdown file with all messages
+3. Save to `docs/linkedin-outreach/[date]-messages.md`