linkedin-automation-cli 1.0.0

package/docs/superpowers/plans/2026-03-13-playwright-fara-migration.md

@@ -0,0 +1,1112 @@
+# Playwright MCP + Fara-7B Migration Plan
+
+> **For agentic workers:** REQUIRED: Use superpowers:subagent-driven-development (if subagents available) or superpowers:executing-plans to implement this plan. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Replace PinchTab with Playwright MCP + Fara-7B vision model so the CLI can visually identify and click the correct Connect button on LinkedIn profiles — solving the 9-button disambiguation problem.
+
+**Architecture:** Go CLI orchestrates two HTTP services: (1) Playwright MCP server (`npx @playwright/mcp@latest --port 3000 --caps vision`) for browser control (navigate, screenshot, click-at-coordinates), and (2) Fara-7B served via Ollama for visual target identification (screenshot → pixel coordinates). The CLI takes a screenshot, sends it to Fara asking "where is the Connect button?", gets back (x,y) coordinates, and tells Playwright to click there.
+
+**Tech Stack:** Go 1.21+, Playwright MCP (Node.js, via npx), Ollama + Fara-7B GGUF (local vision model), Cobra CLI (existing)
+
+**Hardware:** Apple Silicon M1/M2 16GB — Fara-7B Q4_K_M (~5GB RAM, ~5-8s per inference)
+
+---
+
+## Why This Migration
+
+The current PinchTab-based approach has a **fundamental limitation**: its snapshot model provides only `{role, name, ref}` per DOM node — **no coordinates, no position, no bounding boxes**. When LinkedIn shows 9 "Connect" buttons (1 for the profile, 8 for recommended people), the code returns the first DOM match, which is often the wrong button.
+
+This is unsolvable with DOM heuristics. A human solves it by **looking at the page**. Fara-7B does the same — it takes a screenshot and returns pixel coordinates for the correct button.
+
+## File Structure
+
+### New files
+- `internal/playwright/client.go` — Playwright MCP HTTP client (navigate, screenshot, click, type)
+- `internal/playwright/types.go` — MCP request/response types
+- `internal/vision/client.go` — Fara-7B OpenAI-compatible API client
+- `internal/vision/types.go` — Vision request/response types
+- `internal/browser/browser.go` — Browser interface combining Playwright + Vision
+- `internal/browser/actions.go` — High-level actions: ConnectToProfile, SendMessage, etc.
+
+### Modified files
+- `internal/cmd/root.go` — Add flags for Playwright/Fara endpoints
+- `internal/cmd/connect.go` — Use new browser actions instead of PinchTab navigator
+- `internal/cmd/message.go` — Same
+- `internal/cmd/auth.go` — Use Playwright MCP for auth flow
+- `internal/cmd/actions.go` — Update to use new browser actions
+- `go.mod` — No new Go dependencies needed (only stdlib HTTP)
+- `README.md` — New prerequisites (Ollama, Fara-7B, Playwright MCP)
+
+### Preserved (unchanged)
+- `internal/config/` — Profile management
+- `internal/ratelimit/` — Rate limiting
+- `internal/linkedin/validator.go` — URL validation
+- `cmd/linkedin/main.go` — Entry point
+
+### Deprecated (remove after migration)
+- `internal/pinchtab/` — Entire package
+- `internal/linkedin/navigator.go` — PinchTab-based navigator
+- `internal/linkedin/selectors.go` — CSS selectors (no longer needed)
+- `internal/linkedin/detector.go` — DOM-based detection (no longer needed)
+
+---
+
+## Chunk 1: Playwright MCP Client
+
+### Task 1.1: Playwright MCP Types
+
+**Files:**
+- Create: `internal/playwright/types.go`
+
+- [ ] **Step 1: Define MCP JSON-RPC types for Playwright server communication**
+
+The Playwright MCP server in HTTP mode (--port) uses the MCP Streamable HTTP transport.
+We need types for: tool calls (navigate, screenshot, click) and their responses.
+
+```go
+package playwright
+
+// MCPRequest is a JSON-RPC 2.0 request for MCP tool calls
+type MCPRequest struct {
+    JSONRPC string      `json:"jsonrpc"`
+    ID      int         `json:"id"`
+    Method  string      `json:"method"`
+    Params  interface{} `json:"params"`
+}
+
+// MCPResponse is a JSON-RPC 2.0 response
+type MCPResponse struct {
+    JSONRPC string          `json:"jsonrpc"`
+    ID      int             `json:"id"`
+    Result  json.RawMessage `json:"result,omitempty"`
+    Error   *MCPError       `json:"error,omitempty"`
+}
+
+// MCPError represents a JSON-RPC error
+type MCPError struct {
+    Code    int    `json:"code"`
+    Message string `json:"message"`
+}
+
+// ToolCallParams wraps tool name and arguments for MCP tools/call
+type ToolCallParams struct {
+    Name      string                 `json:"name"`
+    Arguments map[string]interface{} `json:"arguments,omitempty"`
+}
+
+// ToolResult contains the tool execution result
+type ToolResult struct {
+    Content []ContentBlock `json:"content"`
+    IsError bool           `json:"isError,omitempty"`
+}
+
+// ContentBlock is a text or image block in tool results
+type ContentBlock struct {
+    Type     string `json:"type"`
+    Text     string `json:"text,omitempty"`
+    Data     string `json:"data,omitempty"`
+    MimeType string `json:"mimeType,omitempty"`
+}
+```
+
+- [ ] **Step 2: Verify compilation**
+
+Run: `go build ./internal/playwright/`
+Expected: no errors
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add internal/playwright/types.go
+git commit -m "feat: add Playwright MCP JSON-RPC types"
+```
+
+### Task 1.2: Playwright MCP Client
+
+**Files:**
+- Create: `internal/playwright/client.go`
+- Test: `internal/playwright/client_test.go`
+
+- [ ] **Step 1: Write test for client initialization and tool call construction**
+
+```go
+package playwright
+
+import (
+    "testing"
+)
+
+func TestNewClient(t *testing.T) {
+    c := NewClient("http://localhost:3000")
+    if c.baseURL != "http://localhost:3000" {
+        t.Errorf("expected base URL http://localhost:3000, got %s", c.baseURL)
+    }
+}
+
+func TestBuildToolCallRequest(t *testing.T) {
+    c := NewClient("http://localhost:3000")
+    req := c.buildToolCall("browser_navigate", map[string]interface{}{
+        "url": "https://linkedin.com",
+    })
+    if req.Method != "tools/call" {
+        t.Errorf("expected method tools/call, got %s", req.Method)
+    }
+}
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `go test -v -run TestNewClient ./internal/playwright/`
+Expected: FAIL — NewClient not defined
+
+- [ ] **Step 3: Implement Client struct with Navigate, Screenshot, Click methods**
+
+```go
+package playwright
+
+import (
+    "bytes"
+    "encoding/json"
+    "fmt"
+    "io"
+    "net/http"
+    "sync"
+    "time"
+)
+
+// Client communicates with Playwright MCP server over HTTP
+type Client struct {
+    baseURL   string
+    sessionID string
+    client    *http.Client
+    mu        sync.Mutex
+    nextID    int
+}
+
+// NewClient creates a Playwright MCP client
+func NewClient(baseURL string) *Client {
+    return &Client{
+        baseURL: baseURL,
+        client: &http.Client{
+            Timeout: 60 * time.Second,
+        },
+        nextID: 1,
+    }
+}
+
+func (c *Client) buildToolCall(name string, args map[string]interface{}) *MCPRequest {
+    c.mu.Lock()
+    id := c.nextID
+    c.nextID++
+    c.mu.Unlock()
+
+    return &MCPRequest{
+        JSONRPC: "2.0",
+        ID:      id,
+        Method:  "tools/call",
+        Params: ToolCallParams{
+            Name:      name,
+            Arguments: args,
+        },
+    }
+}
+
+func (c *Client) callTool(name string, args map[string]interface{}) (*ToolResult, error) {
+    req := c.buildToolCall(name, args)
+    body, err := json.Marshal(req)
+    if err != nil {
+        return nil, fmt.Errorf("failed to marshal request: %w", err)
+    }
+
+    httpReq, err := http.NewRequest("POST", c.baseURL+"/mcp", bytes.NewReader(body))
+    if err != nil {
+        return nil, fmt.Errorf("failed to create request: %w", err)
+    }
+    httpReq.Header.Set("Content-Type", "application/json")
+    httpReq.Header.Set("Accept", "application/json")
+    if c.sessionID != "" {
+        httpReq.Header.Set("Mcp-Session-Id", c.sessionID)
+    }
+
+    resp, err := c.client.Do(httpReq)
+    if err != nil {
+        return nil, fmt.Errorf("failed to call tool %s: %w", name, err)
+    }
+    defer resp.Body.Close()
+
+    // Capture session ID from response
+    if sid := resp.Header.Get("Mcp-Session-Id"); sid != "" {
+        c.sessionID = sid
+    }
+
+    respBody, err := io.ReadAll(resp.Body)
+    if err != nil {
+        return nil, fmt.Errorf("failed to read response: %w", err)
+    }
+
+    var mcpResp MCPResponse
+    if err := json.Unmarshal(respBody, &mcpResp); err != nil {
+        return nil, fmt.Errorf("failed to parse response: %w", err)
+    }
+
+    if mcpResp.Error != nil {
+        return nil, fmt.Errorf("MCP error %d: %s", mcpResp.Error.Code, mcpResp.Error.Message)
+    }
+
+    var result ToolResult
+    if err := json.Unmarshal(mcpResp.Result, &result); err != nil {
+        return nil, fmt.Errorf("failed to parse tool result: %w", err)
+    }
+
+    return &result, nil
+}
+
+// Navigate loads a URL in the browser
+func (c *Client) Navigate(url string) error {
+    _, err := c.callTool("browser_navigate", map[string]interface{}{
+        "url": url,
+    })
+    return err
+}
+
+// Screenshot takes a screenshot and returns base64-encoded PNG
+func (c *Client) Screenshot() (string, error) {
+    result, err := c.callTool("browser_take_screenshot", nil)
+    if err != nil {
+        return "", err
+    }
+
+    for _, block := range result.Content {
+        if block.Type == "image" && block.Data != "" {
+            return block.Data, nil
+        }
+    }
+
+    return "", fmt.Errorf("no image data in screenshot response")
+}
+
+// Click clicks at specific pixel coordinates (vision mode)
+func (c *Client) Click(x, y int) error {
+    _, err := c.callTool("browser_click", map[string]interface{}{
+        "element": fmt.Sprintf("coordinate [%d, %d]", x, y),
+        "ref":     fmt.Sprintf("coord_%d_%d", x, y),
+    })
+    return err
+}
+
+// Snapshot takes an accessibility tree snapshot (for fallback/verification)
+func (c *Client) Snapshot() (string, error) {
+    result, err := c.callTool("browser_snapshot", nil)
+    if err != nil {
+        return "", err
+    }
+
+    for _, block := range result.Content {
+        if block.Type == "text" {
+            return block.Text, nil
+        }
+    }
+
+    return "", fmt.Errorf("no text in snapshot response")
+}
+
+// Type types text into the focused element
+func (c *Client) Type(text string) error {
+    _, err := c.callTool("browser_type", map[string]interface{}{
+        "text": text,
+    })
+    return err
+}
+
+// WaitForText waits for specific text to appear on page
+func (c *Client) WaitForText(text string, timeoutMs int) error {
+    _, err := c.callTool("browser_wait_for_text", map[string]interface{}{
+        "text":    text,
+        "timeout": timeoutMs,
+    })
+    return err
+}
+```
+
+- [ ] **Step 4: Run tests**
+
+Run: `go test -v ./internal/playwright/`
+Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/playwright/
+git commit -m "feat: add Playwright MCP HTTP client"
+```
+
+---
+
+## Chunk 2: Fara-7B Vision Client
+
+### Task 2.1: Vision Types
+
+**Files:**
+- Create: `internal/vision/types.go`
+
+- [ ] **Step 1: Define OpenAI-compatible types for Fara-7B communication**
+
+```go
+package vision
+
+// ChatRequest is an OpenAI-compatible chat completion request
+type ChatRequest struct {
+    Model    string    `json:"model"`
+    Messages []Message `json:"messages"`
+}
+
+// Message contains role and content for chat
+type Message struct {
+    Role    string    `json:"role"`
+    Content []Content `json:"content"`
+}
+
+// Content is a text or image block
+type Content struct {
+    Type     string    `json:"type"`
+    Text     string    `json:"text,omitempty"`
+    ImageURL *ImageURL `json:"image_url,omitempty"`
+}
+
+// ImageURL wraps a base64 data URL
+type ImageURL struct {
+    URL string `json:"url"`
+}
+
+// ChatResponse is the Ollama/OpenAI chat completion response
+type ChatResponse struct {
+    Choices []Choice `json:"choices"`
+}
+
+// Choice contains a message from the model
+type Choice struct {
+    Message ResponseMessage `json:"message"`
+}
+
+// ResponseMessage is the model's response
+type ResponseMessage struct {
+    Content   string     `json:"content"`
+    ToolCalls []ToolCall `json:"tool_calls,omitempty"`
+}
+
+// ToolCall represents a function call from Fara
+type ToolCall struct {
+    Function FunctionCall `json:"function"`
+}
+
+// FunctionCall contains the action details
+type FunctionCall struct {
+    Name      string `json:"name"`
+    Arguments string `json:"arguments"`
+}
+
+// FaraAction is the parsed action from Fara's response
+type FaraAction struct {
+    Action     string `json:"action"`
+    Coordinate [2]int `json:"coordinate"`
+    Text       string `json:"text,omitempty"`
+}
+```
+
+- [ ] **Step 2: Verify compilation**
+
+Run: `go build ./internal/vision/`
+Expected: no errors
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add internal/vision/types.go
+git commit -m "feat: add Fara-7B vision model types"
+```
+
+### Task 2.2: Vision Client
+
+**Files:**
+- Create: `internal/vision/client.go`
+- Test: `internal/vision/client_test.go`
+
+- [ ] **Step 1: Write test for prompt construction and coordinate parsing**
+
+```go
+package vision
+
+import (
+    "testing"
+)
+
+func TestNewClient(t *testing.T) {
+    c := NewClient("http://localhost:11434", "fara-7b")
+    if c.baseURL != "http://localhost:11434" {
+        t.Errorf("unexpected base URL: %s", c.baseURL)
+    }
+    if c.model != "fara-7b" {
+        t.Errorf("unexpected model: %s", c.model)
+    }
+}
+
+func TestParseCoordinates(t *testing.T) {
+    tests := []struct {
+        name    string
+        input   string
+        wantX   int
+        wantY   int
+        wantErr bool
+    }{
+        {
+            name:  "tool call format",
+            input: `{"action": "left_click", "coordinate": [850, 120]}`,
+            wantX: 850, wantY: 120,
+        },
+        {
+            name:  "coordinate in text",
+            input: `I will click at coordinate [423, 256]`,
+            wantX: 423, wantY: 256,
+        },
+        {
+            name:    "no coordinate",
+            input:   "I don't see a Connect button",
+            wantErr: true,
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            x, y, err := parseCoordinates(tt.input)
+            if tt.wantErr {
+                if err == nil {
+                    t.Error("expected error, got nil")
+                }
+                return
+            }
+            if err != nil {
+                t.Fatalf("unexpected error: %v", err)
+            }
+            if x != tt.wantX || y != tt.wantY {
+                t.Errorf("got (%d, %d), want (%d, %d)", x, y, tt.wantX, tt.wantY)
+            }
+        })
+    }
+}
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `go test -v -run TestParseCoordinates ./internal/vision/`
+Expected: FAIL
+
+- [ ] **Step 3: Implement vision client**
+
+```go
+package vision
+
+import (
+    "bytes"
+    "encoding/json"
+    "fmt"
+    "io"
+    "net/http"
+    "regexp"
+    "strconv"
+    "time"
+)
+
+// Client communicates with Fara-7B via OpenAI-compatible API
+type Client struct {
+    baseURL string
+    model   string
+    client  *http.Client
+}
+
+// NewClient creates a vision client for Fara-7B
+func NewClient(baseURL string, model string) *Client {
+    return &Client{
+        baseURL: baseURL,
+        model:   model,
+        client: &http.Client{
+            Timeout: 120 * time.Second, // Vision inference can be slow
+        },
+    }
+}
+
+// IdentifyElement sends a screenshot to Fara and gets click coordinates
+func (c *Client) IdentifyElement(screenshotBase64 string, task string) (int, int, error) {
+    req := ChatRequest{
+        Model: c.model,
+        Messages: []Message{
+            {
+                Role: "user",
+                Content: []Content{
+                    {Type: "text", Text: task},
+                    {
+                        Type: "image_url",
+                        ImageURL: &ImageURL{
+                            URL: "data:image/png;base64," + screenshotBase64,
+                        },
+                    },
+                },
+            },
+        },
+    }
+
+    body, err := json.Marshal(req)
+    if err != nil {
+        return 0, 0, fmt.Errorf("failed to marshal vision request: %w", err)
+    }
+
+    resp, err := c.client.Post(
+        c.baseURL+"/v1/chat/completions",
+        "application/json",
+        bytes.NewReader(body),
+    )
+    if err != nil {
+        return 0, 0, fmt.Errorf("failed to call vision model: %w", err)
+    }
+    defer resp.Body.Close()
+
+    respBody, err := io.ReadAll(resp.Body)
+    if err != nil {
+        return 0, 0, fmt.Errorf("failed to read vision response: %w", err)
+    }
+
+    if resp.StatusCode != http.StatusOK {
+        return 0, 0, fmt.Errorf("vision model returned %d: %s", resp.StatusCode, string(respBody))
+    }
+
+    var chatResp ChatResponse
+    if err := json.Unmarshal(respBody, &chatResp); err != nil {
+        return 0, 0, fmt.Errorf("failed to parse vision response: %w", err)
+    }
+
+    if len(chatResp.Choices) == 0 {
+        return 0, 0, fmt.Errorf("vision model returned no choices")
+    }
+
+    content := chatResp.Choices[0].Message.Content
+    return parseCoordinates(content)
+}
+
+// VerifyState sends a screenshot and asks a yes/no question about page state
+func (c *Client) VerifyState(screenshotBase64 string, question string) (string, error) {
+    req := ChatRequest{
+        Model: c.model,
+        Messages: []Message{
+            {
+                Role: "user",
+                Content: []Content{
+                    {Type: "text", Text: question + " Answer concisely."},
+                    {
+                        Type: "image_url",
+                        ImageURL: &ImageURL{
+                            URL: "data:image/png;base64," + screenshotBase64,
+                        },
+                    },
+                },
+            },
+        },
+    }
+
+    body, err := json.Marshal(req)
+    if err != nil {
+        return "", fmt.Errorf("failed to marshal: %w", err)
+    }
+
+    resp, err := c.client.Post(
+        c.baseURL+"/v1/chat/completions",
+        "application/json",
+        bytes.NewReader(body),
+    )
+    if err != nil {
+        return "", fmt.Errorf("failed to call vision model: %w", err)
+    }
+    defer resp.Body.Close()
+
+    respBody, err := io.ReadAll(resp.Body)
+    if err != nil {
+        return "", err
+    }
+
+    var chatResp ChatResponse
+    if err := json.Unmarshal(respBody, &chatResp); err != nil {
+        return "", err
+    }
+
+    if len(chatResp.Choices) == 0 {
+        return "", fmt.Errorf("no choices in response")
+    }
+
+    return chatResp.Choices[0].Message.Content, nil
+}
+
+// Health checks if the vision model is available
+func (c *Client) Health() error {
+    resp, err := c.client.Get(c.baseURL + "/v1/models")
+    if err != nil {
+        return fmt.Errorf("vision model not reachable: %w", err)
+    }
+    defer resp.Body.Close()
+
+    if resp.StatusCode != http.StatusOK {
+        return fmt.Errorf("vision model returned status %d", resp.StatusCode)
+    }
+    return nil
+}
+
+var coordRegex = regexp.MustCompile(`\[(\d+),\s*(\d+)\]`)
+
+func parseCoordinates(text string) (int, int, error) {
+    matches := coordRegex.FindStringSubmatch(text)
+    if len(matches) < 3 {
+        return 0, 0, fmt.Errorf("no coordinates found in response: %s", text)
+    }
+
+    x, err := strconv.Atoi(matches[1])
+    if err != nil {
+        return 0, 0, fmt.Errorf("invalid x coordinate: %w", err)
+    }
+
+    y, err := strconv.Atoi(matches[2])
+    if err != nil {
+        return 0, 0, fmt.Errorf("invalid y coordinate: %w", err)
+    }
+
+    return x, y, nil
+}
+```
+
+- [ ] **Step 4: Run tests**
+
+Run: `go test -v ./internal/vision/`
+Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/vision/
+git commit -m "feat: add Fara-7B vision client with coordinate parsing"
+```
+
+---
+
+## Chunk 3: Browser Actions (Combining Playwright + Vision)
+
+### Task 3.1: Browser Interface
+
+**Files:**
+- Create: `internal/browser/browser.go`
+- Create: `internal/browser/actions.go`
+- Test: `internal/browser/actions_test.go`
+
+- [ ] **Step 1: Define Browser struct that combines Playwright + Vision clients**
+
+```go
+package browser
+
+import (
+    "fmt"
+    "time"
+
+    "github.com/thaddeus-git/linkedin-cli/internal/playwright"
+    "github.com/thaddeus-git/linkedin-cli/internal/vision"
+)
+
+// Browser combines Playwright (hands) and Vision (eyes) for web automation
+type Browser struct {
+    pw     *playwright.Client
+    vis    *vision.Client
+    dryRun bool
+}
+
+// NewBrowser creates a browser with both automation and vision capabilities
+func NewBrowser(playwrightURL, visionURL, visionModel string, dryRun bool) *Browser {
+    return &Browser{
+        pw:     playwright.NewClient(playwrightURL),
+        vis:    vision.NewClient(visionURL, visionModel),
+        dryRun: dryRun,
+    }
+}
+
+// Health checks both Playwright MCP and Vision model are available
+func (b *Browser) Health() error {
+    // TODO: Add Playwright health check (initialize/list tools)
+    if err := b.vis.Health(); err != nil {
+        return fmt.Errorf("vision model: %w", err)
+    }
+    return nil
+}
+```
+
+- [ ] **Step 2: Implement ConnectToProfile action — the core flow**
+
+```go
+package browser
+
+// ConnectResult describes the outcome of a connection attempt
+type ConnectResult struct {
+    Success      bool
+    Status       string // "sent", "pending", "already_connected", "not_found", "error"
+    Message      string
+    Screenshots  []string // base64 screenshots for debugging
+}
+
+// ConnectToProfile navigates to a profile and clicks Connect
+func (b *Browser) ConnectToProfile(profileURL string, note string) (*ConnectResult, error) {
+    result := &ConnectResult{}
+
+    if b.dryRun {
+        result.Success = true
+        result.Status = "dry_run"
+        result.Message = fmt.Sprintf("Would connect to %s", profileURL)
+        return result, nil
+    }
+
+    // Step 1: Navigate to profile
+    if err := b.pw.Navigate(profileURL); err != nil {
+        return nil, fmt.Errorf("failed to navigate to profile: %w", err)
+    }
+    time.Sleep(3 * time.Second) // Wait for page load
+
+    // Step 2: Take screenshot
+    screenshot, err := b.pw.Screenshot()
+    if err != nil {
+        return nil, fmt.Errorf("failed to take screenshot: %w", err)
+    }
+    result.Screenshots = append(result.Screenshots, screenshot)
+
+    // Step 3: Ask Fara to find the Connect button
+    x, y, err := b.vis.IdentifyElement(screenshot,
+        "Click the Connect button for this person's LinkedIn profile. "+
+            "The Connect button is in the main profile header area near the profile photo, "+
+            "NOT in the 'People also viewed' or 'People you may know' sidebar sections.")
+    if err != nil {
+        // Connect button might be hidden under "More" menu
+        return b.tryMoreMenuConnect(screenshot, note, result)
+    }
+
+    // Step 4: Click at the identified coordinates
+    if err := b.pw.Click(x, y); err != nil {
+        return nil, fmt.Errorf("failed to click Connect at (%d, %d): %w", x, y, err)
+    }
+    time.Sleep(2 * time.Second)
+
+    // Step 5: Handle optional note and Send confirmation
+    return b.handleConnectDialog(note, result)
+}
+
+// tryMoreMenuConnect handles the case where Connect is hidden under "... More"
+func (b *Browser) tryMoreMenuConnect(screenshot string, note string, result *ConnectResult) (*ConnectResult, error) {
+    // Ask Fara to find the "More" button
+    x, y, err := b.vis.IdentifyElement(screenshot,
+        "Click the 'More' or '...' button in the profile header area. "+
+            "This is typically a three-dot menu button near the profile actions.")
+    if err != nil {
+        result.Status = "not_found"
+        result.Message = "Connect button not found on this profile"
+        return result, nil
+    }
+
+    // Click More menu
+    if err := b.pw.Click(x, y); err != nil {
+        return nil, fmt.Errorf("failed to click More menu: %w", err)
+    }
+    time.Sleep(1500 * time.Millisecond)
+
+    // Take new screenshot after menu opens
+    screenshot2, err := b.pw.Screenshot()
+    if err != nil {
+        return nil, fmt.Errorf("failed to screenshot after More menu: %w", err)
+    }
+    result.Screenshots = append(result.Screenshots, screenshot2)
+
+    // Now find Connect in the opened menu
+    x, y, err = b.vis.IdentifyElement(screenshot2,
+        "Click the Connect option in the dropdown menu that is currently open.")
+    if err != nil {
+        result.Status = "not_found"
+        result.Message = "Connect not found in More menu either"
+        return result, nil
+    }
+
+    if err := b.pw.Click(x, y); err != nil {
+        return nil, fmt.Errorf("failed to click Connect in menu: %w", err)
+    }
+    time.Sleep(2 * time.Second)
+
+    return b.handleConnectDialog(note, result)
+}
+
+// handleConnectDialog handles the note input and Send confirmation dialog
+func (b *Browser) handleConnectDialog(note string, result *ConnectResult) (*ConnectResult, error) {
+    // Take screenshot to see if a dialog appeared
+    screenshot, err := b.pw.Screenshot()
+    if err != nil {
+        return nil, fmt.Errorf("failed to screenshot dialog: %w", err)
+    }
+    result.Screenshots = append(result.Screenshots, screenshot)
+
+    // Check if there's a note input and we want to add a note
+    if note != "" {
+        x, y, err := b.vis.IdentifyElement(screenshot,
+            "Click the 'Add a note' button if visible, or find the text input field for adding a personal note.")
+        if err == nil {
+            if err := b.pw.Click(x, y); err == nil {
+                time.Sleep(500 * time.Millisecond)
+                b.pw.Type(note)
+                time.Sleep(500 * time.Millisecond)
+            }
+        }
+    }
+
+    // Take screenshot and find Send button
+    screenshot, err = b.pw.Screenshot()
+    if err != nil {
+        return nil, err
+    }
+
+    x, y, err := b.vis.IdentifyElement(screenshot,
+        "Click the 'Send' button to send the connection request. "+
+            "This is the primary action button in the dialog/modal.")
+    if err == nil {
+        if err := b.pw.Click(x, y); err != nil {
+            return nil, fmt.Errorf("failed to click Send: %w", err)
+        }
+        time.Sleep(2 * time.Second)
+    }
+
+    // Step 6: Verify the connection was sent
+    return b.verifyConnectSent(result)
+}
+
+// verifyConnectSent checks if the connection request was actually sent
+func (b *Browser) verifyConnectSent(result *ConnectResult) (*ConnectResult, error) {
+    screenshot, err := b.pw.Screenshot()
+    if err != nil {
+        return nil, err
+    }
+    result.Screenshots = append(result.Screenshots, screenshot)
+
+    answer, err := b.vis.VerifyState(screenshot,
+        "Look at this LinkedIn profile page. Is there a 'Pending' indicator showing that a connection request was sent? "+
+            "Or is the Connect button still visible? "+
+            "Answer with one of: PENDING, CONNECT_VISIBLE, ALREADY_CONNECTED, UNCLEAR")
+    if err != nil {
+        result.Status = "error"
+        result.Message = fmt.Sprintf("Failed to verify: %v", err)
+        return result, nil
+    }
+
+    switch {
+    case contains(answer, "PENDING"):
+        result.Success = true
+        result.Status = "sent"
+        result.Message = "Connection request sent successfully"
+    case contains(answer, "ALREADY_CONNECTED"):
+        result.Status = "already_connected"
+        result.Message = "Already connected with this person"
+    case contains(answer, "CONNECT_VISIBLE"):
+        result.Status = "error"
+        result.Message = "Connect button still visible — request may not have been sent"
+    default:
+        result.Status = "unclear"
+        result.Message = fmt.Sprintf("Verification unclear: %s", answer)
+    }
+
+    return result, nil
+}
+
+func contains(s, substr string) bool {
+    return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsCI(s, substr))
+}
+
+func containsCI(s, substr string) bool {
+    // Case-insensitive contains
+    import "strings"
+    return strings.Contains(strings.ToUpper(s), strings.ToUpper(substr))
+}
+```
+
+NOTE: The `contains`/`containsCI` functions above have a syntax issue — the import inside a function body is invalid Go. Fix during implementation:
+
+```go
+import "strings"
+
+func containsCI(s, substr string) bool {
+    return strings.Contains(strings.ToUpper(s), strings.ToUpper(substr))
+}
+```
+
+- [ ] **Step 3: Verify compilation**
+
+Run: `go build ./internal/browser/`
+Expected: no errors
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add internal/browser/
+git commit -m "feat: add browser actions combining Playwright + Fara vision"
+```
+
+---
+
+## Chunk 4: CLI Integration
+
+### Task 4.1: Update Root Command with New Endpoints
+
+**Files:**
+- Modify: `internal/cmd/root.go`
+
+- [ ] **Step 1: Add flags for Playwright and Vision endpoints**
+
+Add to root.go:
+- `--playwright-url` flag (default: `http://localhost:3000`, env: `PLAYWRIGHT_URL`)
+- `--vision-url` flag (default: `http://localhost:11434`, env: `VISION_URL`)
+- `--vision-model` flag (default: `fara-7b`, env: `VISION_MODEL`)
+- Helper function `getBrowser()` that creates a `browser.Browser` instance
+
+- [ ] **Step 2: Verify build**
+
+Run: `go build ./cmd/linkedin`
+
+- [ ] **Step 3: Commit**
+
+### Task 4.2: Update Connect Command
+
+**Files:**
+- Modify: `internal/cmd/connect.go` (or `actions.go` depending on current structure)
+
+- [ ] **Step 1: Replace PinchTab navigator calls with browser.ConnectToProfile**
+
+The connect command should:
+1. Create browser via `getBrowser()`
+2. Call `browser.ConnectToProfile(url, note)`
+3. Report result based on ConnectResult.Status
+4. Save screenshot on failure for debugging
+
+- [ ] **Step 2: Test with dry-run**
+
+Run: `go run ./cmd/linkedin connect --profile thaddeus --url linkedin.com/in/test --dry-run`
+Expected: "[dry-run] Would connect to..."
+
+- [ ] **Step 3: Commit**
+
+### Task 4.3: Update Auth Command
+
+**Files:**
+- Modify: `internal/cmd/auth.go`
+
+- [ ] **Step 1: Replace PinchTab auth flow with Playwright-based auth**
+
+Auth should:
+1. Start Playwright MCP (or verify it's running)
+2. Navigate to linkedin.com/login
+3. Wait for user to log in (press Enter)
+4. Use vision to verify logged-in state
+5. Save profile config
+
+- [ ] **Step 2: Commit**
+
+---
+
+## Chunk 5: Setup & Documentation
+
+### Task 5.1: Installation Guide
+
+**Files:**
+- Modify: `README.md`
+
+- [ ] **Step 1: Update prerequisites**
+
+```markdown
+## Prerequisites
+
+1. **Go 1.21+** — [Install Go](https://go.dev/doc/install)
+2. **Node.js 18+** — [Install Node.js](https://nodejs.org/)
+3. **Ollama** — Local model server
+   ```bash
+   brew install ollama
+   ollama serve  # Keep running in a terminal
+   ollama pull bartowski/microsoft_Fara-7B-GGUF:Q4_K_M
+   ```
+4. **Start Playwright MCP** — Browser automation server
+   ```bash
+   npx @playwright/mcp@latest --port 3000 --caps vision \
+     --user-data-dir ~/.linkedin-cli/browser-profile
+   # Keep running in a terminal
+   ```
+```
+
+- [ ] **Step 2: Commit**
+
+### Task 5.2: Startup Script
+
+**Files:**
+- Create: `scripts/start.sh`
+
+- [ ] **Step 1: Create convenience startup script**
+
+```bash
+#!/bin/bash
+# Start LinkedIn CLI services
+
+echo "Starting Ollama..."
+ollama serve &
+OLLAMA_PID=$!
+
+echo "Starting Playwright MCP..."
+npx @playwright/mcp@latest --port 3000 --caps vision \
+  --user-data-dir ~/.linkedin-cli/browser-profile &
+PW_PID=$!
+
+echo ""
+echo "Services running:"
+echo "  Ollama:     http://localhost:11434 (PID: $OLLAMA_PID)"
+echo "  Playwright: http://localhost:3000  (PID: $PW_PID)"
+echo ""
+echo "Press Ctrl+C to stop all services"
+
+trap "kill $OLLAMA_PID $PW_PID 2>/dev/null" EXIT
+wait
+```
+
+- [ ] **Step 2: Commit**
+
+---
+
+## Chunk 6: Cleanup
+
+### Task 6.1: Remove PinchTab Dependency
+
+- [ ] **Step 1: Remove PinchTab imports from all files**
+- [ ] **Step 2: Delete `internal/pinchtab/` directory**
+- [ ] **Step 3: Delete PinchTab-specific navigator code**
+- [ ] **Step 4: Update go.mod (remove unused deps)**
+- [ ] **Step 5: Run full test suite**
+
+Run: `go test ./... && go build ./cmd/linkedin`
+Expected: all pass
+
+- [ ] **Step 6: Commit**
+
+```bash
+git commit -m "refactor: remove PinchTab dependency, complete migration to Playwright+Fara"
+```
+
+---
+
+## Summary
+
+| Component | Technology | Purpose |
+|-----------|-----------|---------|
+| Browser control | Playwright MCP (`--port 3000 --caps vision`) | Navigate, screenshot, click(x,y) |
+| Visual intelligence | Fara-7B via Ollama | Identify correct UI elements from screenshots |
+| CLI orchestration | Go + Cobra | Profiles, rate limits, config, command structure |
+| Session persistence | Playwright `--user-data-dir` | LinkedIn login survives restarts |
+
+**Total estimated effort:** 1-2 weeks
+**Risk:** Fara-7B accuracy on LinkedIn (~85-90% expected). Mitigated by retry with refined prompts.