linkedin-automation-cli 1.0.0

package/docs/plans/2025-03-03-linkedin-cli-implementation.md

@@ -0,0 +1,2420 @@
+# LinkedIn CLI Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Build a Go CLI that wraps PinchTab HTTP API to automate LinkedIn connection requests and messaging with built-in rate limiting.
+
+**Architecture:** Go CLI using Cobra framework with packages for PinchTab HTTP client, LinkedIn-specific selectors, rate limiting, and configuration management. State stored in JSON files.
+
+**Tech Stack:** Go 1.21+, Cobra (CLI), standard library HTTP client
+
+---
+
+## Prerequisites
+
+- Go 1.21+ installed
+- PinchTab installed and running (`pinchtab` command available)
+- Git initialized in project directory
+
+---
+
+## Task 1: Project Setup
+
+**Files:**
+- Create: `go.mod`
+- Create: `go.sum` (generated)
+- Create: `.gitignore`
+- Create: `README.md`
+
+**Step 1: Initialize Go module**
+
+```bash
+cd /Users/thaddeus/projects/linkedin-cli
+go mod init github.com/thaddeus-git/linkedin-cli
+```
+
+**Step 2: Create .gitignore**
+
+```bash
+cat > .gitignore << 'EOF'
+# Binaries
+linkedin-cli
+*.exe
+
+# Go
+vendor/
+*.test
+*.out
+
+# Project
+.linkedin-cli/
+*.log
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+EOF
+```
+
+**Step 3: Create directory structure**
+
+```bash
+mkdir -p cmd/linkedin
+mkdir -p internal/cmd
+mkdir -p internal/config
+mkdir -p internal/pinchtab
+mkdir -p internal/linkedin
+mkdir -p internal/ratelimit
+```
+
+**Step 4: Initial README**
+
+Create: `README.md`
+
+```markdown
+# LinkedIn CLI
+
+A CLI tool for LinkedIn automation using PinchTab.
+
+## Prerequisites
+
+- Go 1.21+
+- PinchTab installed: `curl -fsSL https://pinchtab.com/install.sh | bash`
+
+## Installation
+
+```bash
+go install github.com/thaddeus-git/linkedin-cli/cmd/linkedin@latest
+```
+
+## Quick Start
+
+1. Start PinchTab:
+   ```bash
+   pinchtab
+   ```
+
+2. Authenticate your LinkedIn account:
+   ```bash
+   linkedin auth --profile john
+   ```
+
+3. Send a connection request:
+   ```bash
+   linkedin connect --profile john --url linkedin.com/in/alice
+   ```
+
+## Commands
+
+- `linkedin auth` - Authenticate a LinkedIn profile
+- `linkedin connect` - Send connection requests
+- `linkedin message` - Send direct messages
+- `linkedin queue` - Process batch requests from file
+
+## Configuration
+
+Profiles and rate limits are stored in `~/.linkedin-cli/`.
+
+## License
+
+MIT
+```
+
+**Step 5: Commit**
+
+```bash
+git add go.mod .gitignore README.md
+git commit -m "chore: initialize project structure"
+```
+
+---
+
+## Task 2: PinchTab HTTP Client (Core)
+
+**Files:**
+- Create: `internal/pinchtab/types.go`
+- Create: `internal/pinchtab/client.go`
+- Test: `internal/pinchtab/client_test.go`
+
+**Step 1: Create types**
+
+Create: `internal/pinchtab/types.go`
+
+```go
+package pinchtab
+
+// Instance represents a PinchTab browser instance
+type Instance struct {
+	ID        string `json:"id"`
+	ProfileID string `json:"profileId"`
+	Port      int    `json:"port"`
+	Mode      string `json:"mode"`
+	Status    string `json:"status"`
+}
+
+// Tab represents a browser tab
+type Tab struct {
+	ID         string `json:"id"`
+	InstanceID string `json:"instanceId"`
+	URL        string `json:"url"`
+	Title      string `json:"title"`
+}
+
+// NavigateRequest represents a navigation action
+type NavigateRequest struct {
+	URL            string `json:"url"`
+	TimeoutSeconds int    `json:"timeoutSeconds,omitempty"`
+	BlockImages    bool   `json:"blockImages,omitempty"`
+}
+
+// ActionRequest represents a browser action
+type ActionRequest struct {
+	Kind      string      `json:"kind"`
+	Ref       string      `json:"ref,omitempty"`
+	Selector  string      `json:"selector,omitempty"`
+	Text      string      `json:"text,omitempty"`
+	Value     interface{} `json:"value,omitempty"`
+	Key       string      `json:"key,omitempty"`
+	Direction string      `json:"direction,omitempty"`
+	Amount    int         `json:"amount,omitempty"`
+}
+
+// Snapshot represents the page accessibility tree
+type Snapshot struct {
+	URL     string        `json:"url"`
+	Title   string        `json:"title"`
+	Elements []Element    `json:"elements"`
+}
+
+// Element represents an interactive element
+type Element struct {
+	Ref      string `json:"ref"`
+	Type     string `json:"type"`
+	Role     string `json:"role"`
+	Name     string `json:"name"`
+	Visible  bool   `json:"visible"`
+}
+
+// TextResponse represents extracted text
+type TextResponse struct {
+	Text string `json:"text"`
+}
+```
+
+**Step 2: Create client**
+
+Create: `internal/pinchtab/client.go`
+
+```go
+package pinchtab
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+)
+
+// Client wraps the PinchTab HTTP API
+type Client struct {
+	baseURL string
+	client  *http.Client
+}
+
+// NewClient creates a new PinchTab client
+func NewClient(baseURL string) *Client {
+	if baseURL == "" {
+		baseURL = "http://localhost:9867"
+	}
+	return &Client{
+		baseURL: baseURL,
+		client: &http.Client{
+			Timeout: 30 * time.Second,
+		},
+	}
+}
+
+// StartInstance starts a new browser instance
+func (c *Client) StartInstance(profileID string) (*Instance, error) {
+	reqBody := map[string]string{
+		"profileId": profileID,
+		"mode":      "headed",
+	}
+	
+	var instance Instance
+	err := c.post("/instances/start", reqBody, &instance)
+	if err != nil {
+		return nil, fmt.Errorf("failed to start instance: %w", err)
+	}
+	
+	return &instance, nil
+}
+
+// StopInstance stops a browser instance
+func (c *Client) StopInstance(instanceID string) error {
+	return c.post(fmt.Sprintf("/instances/%s/stop", instanceID), nil, nil)
+}
+
+// NewTab creates a new tab in an instance
+func (c *Client) NewTab(instanceID string, url string) (*Tab, error) {
+	reqBody := map[string]string{
+		"url": url,
+	}
+	
+	var tab Tab
+	err := c.post(fmt.Sprintf("/instances/%s/tabs/open", instanceID), reqBody, &tab)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create tab: %w", err)
+	}
+	
+	return &tab, nil
+}
+
+// Navigate navigates a tab to a URL
+func (c *Client) Navigate(tabID string, req NavigateRequest) error {
+	return c.post(fmt.Sprintf("/tabs/%s/navigate", tabID), req, nil)
+}
+
+// GetSnapshot gets the accessibility tree snapshot
+func (c *Client) GetSnapshot(tabID string, filter string) (*Snapshot, error) {
+	url := fmt.Sprintf("/tabs/%s/snapshot", tabID)
+	if filter != "" {
+		url += "?filter=" + filter
+	}
+	
+	var snapshot Snapshot
+	err := c.get(url, &snapshot)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get snapshot: %w", err)
+	}
+	
+	return &snapshot, nil
+}
+
+// GetText extracts text from a tab
+func (c *Client) GetText(tabID string) (*TextResponse, error) {
+	var resp TextResponse
+	err := c.get(fmt.Sprintf("/tabs/%s/text", tabID), &resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get text: %w", err)
+	}
+	
+	return &resp, nil
+}
+
+// Click clicks an element
+func (c *Client) Click(tabID string, ref string) error {
+	req := ActionRequest{
+		Kind: "click",
+		Ref:  ref,
+	}
+	return c.post(fmt.Sprintf("/tabs/%s/actions", tabID), []ActionRequest{req}, nil)
+}
+
+// HumanClick clicks with human-like randomization
+func (c *Client) HumanClick(tabID string, ref string) error {
+	req := ActionRequest{
+		Kind: "humanClick",
+		Ref:  ref,
+	}
+	return c.post(fmt.Sprintf("/tabs/%s/actions", tabID), []ActionRequest{req}, nil)
+}
+
+// Fill fills an input field
+func (c *Client) Fill(tabID string, ref string, text string) error {
+	req := ActionRequest{
+		Kind: "fill",
+		Ref:  ref,
+		Text: text,
+	}
+	return c.post(fmt.Sprintf("/tabs/%s/actions", tabID), []ActionRequest{req}, nil)
+}
+
+// HumanType types with human-like delays
+func (c *Client) HumanType(tabID string, ref string, text string) error {
+	req := ActionRequest{
+		Kind: "type",
+		Ref:  ref,
+		Text: text,
+	}
+	return c.post(fmt.Sprintf("/tabs/%s/actions", tabID), []ActionRequest{req}, nil)
+}
+
+// Execute runs JavaScript in the tab
+func (c *Client) Execute(tabID string, script string) (interface{}, error) {
+	req := map[string]string{
+		"script": script,
+	}
+	
+	var result interface{}
+	err := c.post(fmt.Sprintf("/tabs/%s/evaluate", tabID), req, &result)
+	if err != nil {
+		return nil, fmt.Errorf("failed to execute script: %w", err)
+	}
+	
+	return result, nil
+}
+
+// post makes a POST request
+func (c *Client) post(path string, body interface{}, result interface{}) error {
+	var bodyReader io.Reader
+	if body != nil {
+		jsonBody, err := json.Marshal(body)
+		if err != nil {
+			return fmt.Errorf("failed to marshal request: %w", err)
+		}
+		bodyReader = bytes.NewReader(jsonBody)
+	}
+	
+	req, err := http.NewRequest("POST", c.baseURL+path, bodyReader)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+	
+	if body != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode >= 400 {
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("request failed with status %d: %s", resp.StatusCode, string(bodyBytes))
+	}
+	
+	if result != nil {
+		if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
+			return fmt.Errorf("failed to decode response: %w", err)
+		}
+	}
+	
+	return nil
+}
+
+// get makes a GET request
+func (c *Client) get(path string, result interface{}) error {
+	resp, err := c.client.Get(c.baseURL + path)
+	if err != nil {
+		return fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode >= 400 {
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("request failed with status %d: %s", resp.StatusCode, string(bodyBytes))
+	}
+	
+	if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
+		return fmt.Errorf("failed to decode response: %w", err)
+	}
+	
+	return nil
+}
+```
+
+**Step 3: Write test**
+
+Create: `internal/pinchtab/client_test.go`
+
+```go
+package pinchtab
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestNewClient(t *testing.T) {
+	client := NewClient("")
+	if client.baseURL != "http://localhost:9867" {
+		t.Errorf("expected default URL, got %s", client.baseURL)
+	}
+	
+	client = NewClient("http://custom:8080")
+	if client.baseURL != "http://custom:8080" {
+		t.Errorf("expected custom URL, got %s", client.baseURL)
+	}
+}
+
+func TestGetSnapshot(t *testing.T) {
+	// Mock server
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/tabs/test-tab/snapshot" {
+			t.Errorf("unexpected path: %s", r.URL.Path)
+		}
+		
+		snapshot := Snapshot{
+			URL:   "https://linkedin.com",
+			Title: "LinkedIn",
+			Elements: []Element{
+				{Ref: "e0", Type: "button", Name: "Connect"},
+			},
+		}
+		json.NewEncoder(w).Encode(snapshot)
+	}))
+	defer server.Close()
+	
+	client := NewClient(server.URL)
+	snapshot, err := client.GetSnapshot("test-tab", "")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	
+	if snapshot.Title != "LinkedIn" {
+		t.Errorf("expected title 'LinkedIn', got %s", snapshot.Title)
+	}
+	
+	if len(snapshot.Elements) != 1 {
+		t.Errorf("expected 1 element, got %d", len(snapshot.Elements))
+	}
+}
+
+func TestGetSnapshot_Error(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte(`{"error": "tab not found"}`))
+	}))
+	defer server.Close()
+	
+	client := NewClient(server.URL)
+	_, err := client.GetSnapshot("invalid-tab", "")
+	if err == nil {
+		t.Error("expected error, got nil")
+	}
+}
+```
+
+**Step 4: Run tests**
+
+```bash
+cd /Users/thaddeus/projects/linkedin-cli
+go test ./internal/pinchtab/... -v
+```
+
+Expected: 3 tests PASS
+
+**Step 5: Commit**
+
+```bash
+git add internal/pinchtab/
+git commit -m "feat: add PinchTab HTTP client"
+```
+
+---
+
+## Task 3: Configuration Management
+
+**Files:**
+- Create: `internal/config/config.go`
+- Create: `internal/config/profile.go`
+- Test: `internal/config/config_test.go`
+
+**Step 1: Create config types**
+
+Create: `internal/config/profile.go`
+
+```go
+package config
+
+import "time"
+
+// Profile represents a LinkedIn profile configuration
+type Profile struct {
+	Name            string    `json:"name"`
+	PinchTabProfile string    `json:"pinchtab_profile"`
+	CreatedAt       time.Time `json:"created_at"`
+	LastUsed        time.Time `json:"last_used"`
+}
+
+// RateLimits tracks rate limit state per profile
+type RateLimits struct {
+	Connections RateLimit `json:"connections"`
+	Messages    RateLimit `json:"messages"`
+}
+
+// RateLimit tracks a single rate limit
+type RateLimit struct {
+	Today      int       `json:"today"`
+	ThisWeek   int       `json:"this_week"`
+	LastAction time.Time `json:"last_action"`
+}
+
+// CanConnect checks if connection request is allowed
+func (r *RateLimits) CanConnect(dailyLimit, weeklyLimit int) bool {
+	return r.Connections.Today < dailyLimit && r.Connections.ThisWeek < weeklyLimit
+}
+
+// CanMessage checks if message is allowed
+func (r *RateLimits) CanMessage(dailyLimit int) bool {
+	return r.Messages.Today < dailyLimit
+}
+
+// RecordConnection records a connection request
+func (r *RateLimits) RecordConnection() {
+	r.Connections.Today++
+	r.Connections.ThisWeek++
+	r.Connections.LastAction = time.Now()
+}
+
+// RecordMessage records a message sent
+func (r *RateLimits) RecordMessage() {
+	r.Messages.Today++
+	r.Messages.LastAction = time.Now()
+}
+
+// ResetIfNeeded resets daily/weekly counters if day/week has changed
+func (r *RateLimits) ResetIfNeeded() {
+	now := time.Now()
+	last := r.Connections.LastAction
+	
+	// Reset daily if different day
+	if last.Year() != now.Year() || last.YearDay() != now.YearDay() {
+		r.Connections.Today = 0
+		r.Messages.Today = 0
+	}
+	
+	// Reset weekly if different week
+	_, lastWeek := last.ISOWeek()
+	_, nowWeek := now.ISOWeek()
+	if lastWeek != nowWeek {
+		r.Connections.ThisWeek = 0
+	}
+}
+```
+
+**Step 2: Create config manager**
+
+Create: `internal/config/config.go`
+
+```go
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+// Manager handles configuration and state
+type Manager struct {
+	configDir string
+}
+
+// NewManager creates a new config manager
+func NewManager() (*Manager, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get home directory: %w", err)
+	}
+	
+	configDir := filepath.Join(home, ".linkedin-cli")
+	if err := os.MkdirAll(configDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create config directory: %w", err)
+	}
+	
+	return &Manager{configDir: configDir}, nil
+}
+
+// GetConfigDir returns the config directory path
+func (m *Manager) GetConfigDir() string {
+	return m.configDir
+}
+
+// ProfileExists checks if a profile exists
+func (m *Manager) ProfileExists(name string) bool {
+	path := filepath.Join(m.configDir, "profiles", name+".json")
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+// LoadProfile loads a profile
+func (m *Manager) LoadProfile(name string) (*Profile, error) {
+	path := filepath.Join(m.configDir, "profiles", name+".json")
+	
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, fmt.Errorf("profile '%s' not found", name)
+		}
+		return nil, fmt.Errorf("failed to read profile: %w", err)
+	}
+	
+	var profile Profile
+	if err := json.Unmarshal(data, &profile); err != nil {
+		return nil, fmt.Errorf("failed to parse profile: %w", err)
+	}
+	
+	return &profile, nil
+}
+
+// SaveProfile saves a profile
+func (m *Manager) SaveProfile(profile *Profile) error {
+	profilesDir := filepath.Join(m.configDir, "profiles")
+	if err := os.MkdirAll(profilesDir, 0755); err != nil {
+		return fmt.Errorf("failed to create profiles directory: %w", err)
+	}
+	
+	path := filepath.Join(profilesDir, profile.Name+".json")
+	
+	data, err := json.MarshalIndent(profile, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal profile: %w", err)
+	}
+	
+	if err := os.WriteFile(path, data, 0644); err != nil {
+		return fmt.Errorf("failed to write profile: %w", err)
+	}
+	
+	return nil
+}
+
+// ListProfiles lists all profiles
+func (m *Manager) ListProfiles() ([]string, error) {
+	profilesDir := filepath.Join(m.configDir, "profiles")
+	
+	entries, err := os.ReadDir(profilesDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return []string{}, nil
+		}
+		return nil, fmt.Errorf("failed to read profiles directory: %w", err)
+	}
+	
+	var profiles []string
+	for _, entry := range entries {
+		if !entry.IsDir() && filepath.Ext(entry.Name()) == ".json" {
+			name := entry.Name()[:len(entry.Name())-5] // Remove .json
+			profiles = append(profiles, name)
+		}
+	}
+	
+	return profiles, nil
+}
+
+// DeleteProfile deletes a profile
+func (m *Manager) DeleteProfile(name string) error {
+	path := filepath.Join(m.configDir, "profiles", name+".json")
+	if err := os.Remove(path); err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("profile '%s' not found", name)
+		}
+		return fmt.Errorf("failed to delete profile: %w", err)
+	}
+	return nil
+}
+
+// LoadRateLimits loads rate limits for a profile
+func (m *Manager) LoadRateLimits(profileName string) (*RateLimits, error) {
+	path := filepath.Join(m.configDir, "ratelimit.json")
+	
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return &RateLimits{}, nil
+		}
+		return nil, fmt.Errorf("failed to read rate limits: %w", err)
+	}
+	
+	var allLimits map[string]*RateLimits
+	if err := json.Unmarshal(data, &allLimits); err != nil {
+		return nil, fmt.Errorf("failed to parse rate limits: %w", err)
+	}
+	
+	limits, exists := allLimits[profileName]
+	if !exists {
+		return &RateLimits{}, nil
+	}
+	
+	// Reset counters if needed
+	limits.ResetIfNeeded()
+	
+	return limits, nil
+}
+
+// SaveRateLimits saves rate limits for a profile
+func (m *Manager) SaveRateLimits(profileName string, limits *RateLimits) error {
+	path := filepath.Join(m.configDir, "ratelimit.json")
+	
+	var allLimits map[string]*RateLimits
+	
+	// Load existing
+	data, err := os.ReadFile(path)
+	if err == nil {
+		json.Unmarshal(data, &allLimits)
+	}
+	
+	if allLimits == nil {
+		allLimits = make(map[string]*RateLimits)
+	}
+	
+	allLimits[profileName] = limits
+	
+	// Save all
+	data, err = json.MarshalIndent(allLimits, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal rate limits: %w", err)
+	}
+	
+	if err := os.WriteFile(path, data, 0644); err != nil {
+		return fmt.Errorf("failed to write rate limits: %w", err)
+	}
+	
+	return nil
+}
+
+// UpdateLastUsed updates the last used timestamp for a profile
+func (m *Manager) UpdateLastUsed(profileName string) error {
+	profile, err := m.LoadProfile(profileName)
+	if err != nil {
+		return err
+	}
+	
+	profile.LastUsed = time.Now()
+	return m.SaveProfile(profile)
+}
+```
+
+**Step 3: Write tests**
+
+Create: `internal/config/config_test.go`
+
+```go
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestNewManager(t *testing.T) {
+	mgr, err := NewManager()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	
+	if mgr.configDir == "" {
+		t.Error("config dir should not be empty")
+	}
+	
+	// Cleanup
+	os.RemoveAll(mgr.configDir)
+}
+
+func TestProfileCRUD(t *testing.T) {
+	// Use temp dir for testing
+	tempDir := t.TempDir()
+	mgr := &Manager{configDir: tempDir}
+	
+	// Create profile
+	profile := &Profile{
+		Name:            "test",
+		PinchTabProfile: "linkedin-test",
+		CreatedAt:       time.Now(),
+		LastUsed:        time.Now(),
+	}
+	
+	if err := mgr.SaveProfile(profile); err != nil {
+		t.Fatalf("failed to save profile: %v", err)
+	}
+	
+	// Check exists
+	if !mgr.ProfileExists("test") {
+		t.Error("profile should exist")
+	}
+	
+	// Load
+	loaded, err := mgr.LoadProfile("test")
+	if err != nil {
+		t.Fatalf("failed to load profile: %v", err)
+	}
+	
+	if loaded.Name != "test" {
+		t.Errorf("expected name 'test', got %s", loaded.Name)
+	}
+	
+	// List
+	profiles, err := mgr.ListProfiles()
+	if err != nil {
+		t.Fatalf("failed to list profiles: %v", err)
+	}
+	
+	if len(profiles) != 1 || profiles[0] != "test" {
+		t.Errorf("expected ['test'], got %v", profiles)
+	}
+	
+	// Delete
+	if err := mgr.DeleteProfile("test"); err != nil {
+		t.Fatalf("failed to delete profile: %v", err)
+	}
+	
+	if mgr.ProfileExists("test") {
+		t.Error("profile should not exist after delete")
+	}
+}
+
+func TestRateLimits(t *testing.T) {
+	tempDir := t.TempDir()
+	mgr := &Manager{configDir: tempDir}
+	
+	limits := &RateLimits{
+		Connections: RateLimit{
+			Today:    15,
+			ThisWeek: 87,
+		},
+		Messages: RateLimit{
+			Today: 23,
+		},
+	}
+	
+	// Save
+	if err := mgr.SaveRateLimits("john", limits); err != nil {
+		t.Fatalf("failed to save rate limits: %v", err)
+	}
+	
+	// Load
+	loaded, err := mgr.LoadRateLimits("john")
+	if err != nil {
+		t.Fatalf("failed to load rate limits: %v", err)
+	}
+	
+	if loaded.Connections.Today != 15 {
+		t.Errorf("expected 15 connections today, got %d", loaded.Connections.Today)
+	}
+}
+
+func TestRateLimitCanConnect(t *testing.T) {
+	limits := &RateLimits{
+		Connections: RateLimit{Today: 19, ThisWeek: 99},
+	}
+	
+	if !limits.CanConnect(20, 100) {
+		t.Error("should be able to connect at 19/20 daily")
+	}
+	
+	limits.Connections.Today = 20
+	if limits.CanConnect(20, 100) {
+		t.Error("should not be able to connect at 20/20 daily")
+	}
+}
+```
+
+**Step 4: Run tests**
+
+```bash
+go test ./internal/config/... -v
+```
+
+Expected: 4 tests PASS
+
+**Step 5: Commit**
+
+```bash
+git add internal/config/
+git commit -m "feat: add configuration and profile management"
+```
+
+---
+
+## Task 4: Rate Limiting
+
+**Files:**
+- Create: `internal/ratelimit/limits.go`
+- Create: `internal/ratelimit/limiter.go`
+
+**Step 1: Create limits configuration**
+
+Create: `internal/ratelimit/limits.go`
+
+```go
+package ratelimit
+
+// Limits defines rate limit thresholds
+type Limits struct {
+	ConnectionsDaily  int
+	ConnectionsWeekly int
+	MessagesDaily     int
+	MinDelaySeconds   int
+	MaxDelaySeconds   int
+}
+
+// DefaultLimits returns default LinkedIn-safe limits
+func DefaultLimits() Limits {
+	return Limits{
+		ConnectionsDaily:  20,
+		ConnectionsWeekly: 100,
+		MessagesDaily:     50,
+		MinDelaySeconds:   3,
+		MaxDelaySeconds:   8,
+	}
+}
+
+// ConservativeLimits returns more conservative limits for new accounts
+func ConservativeLimits() Limits {
+	return Limits{
+		ConnectionsDaily:  10,
+		ConnectionsWeekly: 50,
+		MessagesDaily:     25,
+		MinDelaySeconds:   5,
+		MaxDelaySeconds:   12,
+	}
+}
+```
+
+**Step 2: Create limiter**
+
+Create: `internal/ratelimit/limiter.go`
+
+```go
+package ratelimit
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+
+	"github.com/thaddeus-git/linkedin-cli/internal/config"
+)
+
+// Limiter handles rate limiting logic
+type Limiter struct {
+	limits  Limits
+	config  *config.Manager
+	profile string
+}
+
+// NewLimiter creates a new rate limiter
+func NewLimiter(profile string, limits Limits, cfg *config.Manager) *Limiter {
+	return &Limiter{
+		limits:  limits,
+		config:  cfg,
+		profile: profile,
+	}
+}
+
+// CheckConnection checks if a connection request is allowed
+func (l *Limiter) CheckConnection() error {
+	state, err := l.config.LoadRateLimits(l.profile)
+	if err != nil {
+		return fmt.Errorf("failed to load rate limits: %w", err)
+	}
+	
+	if !state.CanConnect(l.limits.ConnectionsDaily, l.limits.ConnectionsWeekly) {
+		return fmt.Errorf(
+			"rate limit exceeded: %d/%d daily, %d/%d weekly connections",
+			state.Connections.Today,
+			l.limits.ConnectionsDaily,
+			state.Connections.ThisWeek,
+			l.limits.ConnectionsWeekly,
+		)
+	}
+	
+	return nil
+}
+
+// CheckMessage checks if a message is allowed
+func (l *Limiter) CheckMessage() error {
+	state, err := l.config.LoadRateLimits(l.profile)
+	if err != nil {
+		return fmt.Errorf("failed to load rate limits: %w", err)
+	}
+	
+	if !state.CanMessage(l.limits.MessagesDaily) {
+		return fmt.Errorf(
+			"rate limit exceeded: %d/%d daily messages",
+			state.Messages.Today,
+			l.limits.MessagesDaily,
+		)
+	}
+	
+	return nil
+}
+
+// RecordConnection records a connection request
+func (l *Limiter) RecordConnection() error {
+	state, err := l.config.LoadRateLimits(l.profile)
+	if err != nil {
+		return err
+	}
+	
+	state.RecordConnection()
+	return l.config.SaveRateLimits(l.profile, state)
+}
+
+// RecordMessage records a message
+func (l *Limiter) RecordMessage() error {
+	state, err := l.config.LoadRateLimits(l.profile)
+	if err != nil {
+		return err
+	}
+	
+	state.RecordMessage()
+	return l.config.SaveRateLimits(l.profile, state)
+}
+
+// GetDelay returns a random delay between min and max seconds
+func (l *Limiter) GetDelay() time.Duration {
+	seconds := rand.Intn(l.limits.MaxDelaySeconds-l.limits.MinDelaySeconds+1) + l.limits.MinDelaySeconds
+	return time.Duration(seconds) * time.Second
+}
+
+// Sleep delays execution for a random duration
+func (l *Limiter) Sleep() {
+	time.Sleep(l.GetDelay())
+}
+
+// Status returns current rate limit status
+func (l *Limiter) Status() (map[string]interface{}, error) {
+	state, err := l.config.LoadRateLimits(l.profile)
+	if err != nil {
+		return nil, err
+	}
+	
+	return map[string]interface{}{
+		"connections_today":    state.Connections.Today,
+		"connections_weekly":   state.Connections.ThisWeek,
+		"connections_limit":    l.limits.ConnectionsDaily,
+		"connections_weekly_limit": l.limits.ConnectionsWeekly,
+		"messages_today":       state.Messages.Today,
+		"messages_limit":       l.limits.MessagesDaily,
+		"last_connection":      state.Connections.LastAction,
+		"last_message":         state.Messages.LastAction,
+	}, nil
+}
+```
+
+**Step 3: Commit**
+
+```bash
+git add internal/ratelimit/
+git commit -m "feat: add rate limiting"
+```
+
+---
+
+## Task 5: LinkedIn Selectors & Navigator
+
+**Files:**
+- Create: `internal/linkedin/selectors.go`
+- Create: `internal/linkedin/navigator.go`
+- Create: `internal/linkedin/validator.go`
+
+**Step 1: Create selectors**
+
+Create: `internal/linkedin/selectors.go`
+
+```go
+package linkedin
+
+// Selectors contains LinkedIn DOM selectors
+// Note: These are fragile and may need updating as LinkedIn changes
+var Selectors = struct {
+	// Connection buttons
+	ConnectButton   string
+	ConnectButtonAlt string
+	
+	// Connection modal
+	ConnectModalTextarea string
+	ConnectModalSend     string
+	ConnectModalCancel   string
+	
+	// Messaging
+	MessageButton      string
+	MessageTextarea    string
+	MessageSendButton  string
+	
+	// Navigation
+	ProfileName        string
+	ProfileHeadline    string
+	ProfileCompany     string
+}{
+	ConnectButton:   "button[aria-label*='Connect']",
+	ConnectButtonAlt: "button:has-text('Connect')",
+	
+	ConnectModalTextarea: "textarea[name='message']",
+	ConnectModalSend:     "button[aria-label='Send now']",
+	ConnectModalCancel:   "button[aria-label='Dismiss']",
+	
+	MessageButton:      "button[aria-label*='Message']",
+	MessageTextarea:    "div[role='textbox']",
+	MessageSendButton:  "button[type='submit']",
+	
+	ProfileName:     "h1",
+	ProfileHeadline: "div.text-body-medium",
+	ProfileCompany:  "a[href*='/company/']",
+}
+```
+
+**Step 2: Create navigator**
+
+Create: `internal/linkedin/navigator.go`
+
+```go
+package linkedin
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/thaddeus-git/linkedin-cli/internal/pinchtab"
+)
+
+// Navigator handles LinkedIn page interactions
+type Navigator struct {
+	client *pinchtab.Client
+}
+
+// NewNavigator creates a new navigator
+func NewNavigator(client *pinchtab.Client) *Navigator {
+	return &Navigator{client: client}
+}
+
+// NavigateToProfile navigates to a LinkedIn profile
+func (n *Navigator) NavigateToProfile(tabID string, profileURL string) error {
+	// Ensure URL is absolute
+	if !strings.HasPrefix(profileURL, "http") {
+		profileURL = "https://linkedin.com/in/" + strings.TrimPrefix(profileURL, "/in/")
+	}
+	
+	req := pinchtab.NavigateRequest{
+		URL:            profileURL,
+		TimeoutSeconds: 30,
+		BlockImages:    true,
+	}
+	
+	if err := n.client.Navigate(tabID, req); err != nil {
+		return fmt.Errorf("failed to navigate: %w", err)
+	}
+	
+	// Wait for page to load
+	time.Sleep(3 * time.Second)
+	
+	return nil
+}
+
+// FindConnectButton finds the connect button in the snapshot
+func (n *Navigator) FindConnectButton(snapshot *pinchtab.Snapshot) (*pinchtab.Element, error) {
+	for _, elem := range snapshot.Elements {
+		if elem.Role == "button" && strings.Contains(strings.ToLower(elem.Name), "connect") {
+			return &elem, nil
+		}
+	}
+	
+	return nil, fmt.Errorf("connect button not found")
+}
+
+// FindMessageButton finds the message button in the snapshot
+func (n *Navigator) FindMessageButton(snapshot *pinchtab.Snapshot) (*pinchtab.Element, error) {
+	for _, elem := range snapshot.Elements {
+		if elem.Role == "button" && strings.Contains(strings.ToLower(elem.Name), "message") {
+			return &elem, nil
+		}
+	}
+	
+	return nil, fmt.Errorf("message button not found")
+}
+
+// ClickConnect clicks the connect button
+func (n *Navigator) ClickConnect(tabID string) error {
+	snapshot, err := n.client.GetSnapshot(tabID, "interactive")
+	if err != nil {
+		return fmt.Errorf("failed to get snapshot: %w", err)
+	}
+	
+	button, err := n.FindConnectButton(snapshot)
+	if err != nil {
+		return err
+	}
+	
+	if err := n.client.HumanClick(tabID, button.Ref); err != nil {
+		return fmt.Errorf("failed to click connect: %w", err)
+	}
+	
+	// Wait for modal
+	time.Sleep(2 * time.Second)
+	
+	return nil
+}
+
+// SendConnectionRequest sends a connection request with optional note
+func (n *Navigator) SendConnectionRequest(tabID string, note string) error {
+	if note != "" {
+		// Check for textarea in modal
+		snapshot, err := n.client.GetSnapshot(tabID, "interactive")
+		if err != nil {
+			return fmt.Errorf("failed to get modal snapshot: %w", err)
+		}
+		
+		// Find textarea
+		var textarea *pinchtab.Element
+		for _, elem := range snapshot.Elements {
+			if elem.Role == "textbox" || strings.Contains(strings.ToLower(elem.Name), "message") {
+				textarea = &elem
+				break
+			}
+		}
+		
+		if textarea != nil {
+			// Type the note
+			if err := n.client.HumanType(tabID, textarea.Ref, note); err != nil {
+				return fmt.Errorf("failed to type note: %w", err)
+			}
+		}
+	}
+	
+	// Find and click send button
+	snapshot, err := n.client.GetSnapshot(tabID, "interactive")
+	if err != nil {
+		return fmt.Errorf("failed to get snapshot for send: %w", err)
+	}
+	
+	var sendButton *pinchtab.Element
+	for _, elem := range snapshot.Elements {
+		if elem.Role == "button" && strings.Contains(strings.ToLower(elem.Name), "send") {
+			sendButton = &elem
+			break
+		}
+	}
+	
+	if sendButton == nil {
+		return fmt.Errorf("send button not found")
+	}
+	
+	if err := n.client.HumanClick(tabID, sendButton.Ref); err != nil {
+		return fmt.Errorf("failed to click send: %w", err)
+	}
+	
+	return nil
+}
+
+// OpenMessageModal opens the message modal
+func (n *Navigator) OpenMessageModal(tabID string) error {
+	snapshot, err := n.client.GetSnapshot(tabID, "interactive")
+	if err != nil {
+		return fmt.Errorf("failed to get snapshot: %w", err)
+	}
+	
+	button, err := n.FindMessageButton(snapshot)
+	if err != nil {
+		return err
+	}
+	
+	if err := n.client.HumanClick(tabID, button.Ref); err != nil {
+		return fmt.Errorf("failed to click message button: %w", err)
+	}
+	
+	time.Sleep(2 * time.Second)
+	return nil
+}
+
+// SendMessage sends a direct message
+func (n *Navigator) SendMessage(tabID string, message string) error {
+	snapshot, err := n.client.GetSnapshot(tabID, "interactive")
+	if err != nil {
+		return fmt.Errorf("failed to get snapshot: %w", err)
+	}
+	
+	// Find message textarea
+	var textarea *pinchtab.Element
+	for _, elem := range snapshot.Elements {
+		if elem.Role == "textbox" || elem.Type == "textbox" {
+			textarea = &elem
+			break
+		}
+	}
+	
+	if textarea == nil {
+		return fmt.Errorf("message textarea not found")
+	}
+	
+	// Type message
+	if err := n.client.HumanType(tabID, textarea.Ref, message); err != nil {
+		return fmt.Errorf("failed to type message: %w", err)
+	}
+	
+	// Find send button
+	snapshot, err = n.client.GetSnapshot(tabID, "interactive")
+	if err != nil {
+		return fmt.Errorf("failed to get snapshot for send: %w", err)
+	}
+	
+	var sendButton *pinchtab.Element
+	for _, elem := range snapshot.Elements {
+		if elem.Role == "button" && strings.Contains(strings.ToLower(elem.Name), "send") {
+			sendButton = &elem
+			break
+		}
+	}
+	
+	if sendButton == nil {
+		return fmt.Errorf("send button not found")
+	}
+	
+	if err := n.client.HumanClick(tabID, sendButton.Ref); err != nil {
+		return fmt.Errorf("failed to click send: %w", err)
+	}
+	
+	return nil
+}
+```
+
+**Step 3: Create validator**
+
+Create: `internal/linkedin/validator.go`
+
+```go
+package linkedin
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+)
+
+// ValidateProfileURL validates a LinkedIn profile URL
+func ValidateProfileURL(input string) (string, error) {
+	// Normalize input
+	input = strings.TrimSpace(input)
+	
+	// Check if it's already a full URL
+	if strings.HasPrefix(input, "http") {
+		u, err := url.Parse(input)
+		if err != nil {
+			return "", fmt.Errorf("invalid URL: %w", err)
+		}
+		
+		if !strings.Contains(u.Host, "linkedin.com") {
+			return "", fmt.Errorf("URL must be from linkedin.com")
+		}
+		
+		if !strings.Contains(u.Path, "/in/") {
+			return "", fmt.Errorf("URL must be a LinkedIn profile (contains /in/)")
+		}
+		
+		return input, nil
+	}
+	
+	// Handle vanity URL format (linkedin.com/in/username or /in/username)
+	if strings.HasPrefix(input, "linkedin.com/in/") || strings.HasPrefix(input, "/in/") {
+		username := strings.TrimPrefix(input, "linkedin.com/in/")
+		username = strings.TrimPrefix(username, "/in/")
+		username = strings.TrimSuffix(username, "/")
+		
+		if username == "" {
+			return "", fmt.Errorf("invalid LinkedIn profile URL")
+		}
+		
+		return fmt.Sprintf("https://linkedin.com/in/%s", username), nil
+	}
+	
+	// Assume it's just a username
+	return fmt.Sprintf("https://linkedin.com/in/%s", input), nil
+}
+
+// ExtractProfileUsername extracts the username from a LinkedIn profile URL
+func ExtractProfileUsername(profileURL string) string {
+	u, err := url.Parse(profileURL)
+	if err != nil {
+		return ""
+	}
+	
+	parts := strings.Split(u.Path, "/")
+	for i, part := range parts {
+		if part == "in" && i+1 < len(parts) {
+			return parts[i+1]
+		}
+	}
+	
+	return ""
+}
+```
+
+**Step 4: Commit**
+
+```bash
+git add internal/linkedin/
+git commit -m "feat: add LinkedIn selectors and navigator"
+```
+
+---
+
+## Task 6: CLI Commands
+
+**Files:**
+- Create: `internal/cmd/root.go`
+- Create: `internal/cmd/auth.go`
+- Create: `internal/cmd/connect.go`
+- Create: `internal/cmd/message.go`
+- Create: `cmd/linkedin/main.go`
+
+**Step 1: Create root command**
+
+Create: `internal/cmd/root.go`
+
+```go
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/config"
+)
+
+var (
+	profileName string
+	dryRun      bool
+	verbose     bool
+)
+
+// rootCmd represents the base command
+var rootCmd = &cobra.Command{
+	Use:   "linkedin",
+	Short: "LinkedIn automation CLI",
+	Long: `A CLI tool for LinkedIn automation using PinchTab.
+
+Prerequisites:
+  1. Install PinchTab: curl -fsSL https://pinchtab.com/install.sh | bash
+  2. Start PinchTab: pinchtab
+
+Examples:
+  # Authenticate a profile
+  linkedin auth --profile john
+
+  # Send a connection request
+  linkedin connect --profile john --url linkedin.com/in/alice
+
+  # Send a message
+  linkedin message --profile john --url linkedin.com/in/alice --message "Hello!"
+`,
+}
+
+// Execute adds all child commands to the root command
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func init() {
+	rootCmd.PersistentFlags().StringVarP(&profileName, "profile", "p", "", "Profile name (env: LINKEDIN_PROFILE)")
+	rootCmd.PersistentFlags().BoolVar(&dryRun, "dry-run", false, "Show what would be done without executing")
+	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "Enable verbose output")
+	
+	// Set profile from environment if not provided
+	if profileName == "" {
+		profileName = os.Getenv("LINKEDIN_PROFILE")
+	}
+}
+
+// getConfigManager returns a config manager
+func getConfigManager() (*config.Manager, error) {
+	return config.NewManager()
+}
+
+// getPinchTabHost returns PinchTab host from environment
+func getPinchTabHost() string {
+	host := os.Getenv("PINCHTAB_HOST")
+	if host == "" {
+		return "http://localhost:9867"
+	}
+	return host
+}
+
+// exitWithError prints error and exits
+func exitWithError(format string, args ...interface{}) {
+	fmt.Fprintf(os.Stderr, "Error: "+format+"\n", args...)
+	os.Exit(1)
+}
+
+// logVerbose prints if verbose mode is enabled
+func logVerbose(format string, args ...interface{}) {
+	if verbose {
+		fmt.Printf("[verbose] "+format+"\n", args...)
+	}
+}
+```
+
+**Step 2: Create auth command**
+
+Create: `internal/cmd/auth.go`
+
+```go
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/config"
+	"github.com/thaddeus-git/linkedin-cli/internal/pinchtab"
+)
+
+func init() {
+	rootCmd.AddCommand(authCmd)
+}
+
+var authCmd = &cobra.Command{
+	Use:   "auth",
+	Short: "Authenticate a LinkedIn profile",
+	Long: `Authenticate a LinkedIn profile by logging in through PinchTab.
+
+This command will:
+1. Start a PinchTab browser instance
+2. Navigate to LinkedIn login page
+3. Wait for you to log in manually
+4. Save the session for future use
+
+Example:
+  linkedin auth --profile john
+`,
+	Run: runAuth,
+}
+
+func runAuth(cmd *cobra.Command, args []string) {
+	if profileName == "" {
+		exitWithError("Profile name is required (--profile or LINKEDIN_PROFILE)")
+	}
+	
+	cfg, err := getConfigManager()
+	if err != nil {
+		exitWithError("Failed to initialize config: %v", err)
+	}
+	
+	// Check if PinchTab is running
+	client := pinchtab.NewClient(getPinchTabHost())
+	
+	fmt.Printf("Starting authentication for profile '%s'...\n", profileName)
+	logVerbose("Using PinchTab at %s", getPinchTabHost())
+	
+	if dryRun {
+		fmt.Println("[dry-run] Would:")
+		fmt.Printf("  - Start PinchTab instance with profile 'linkedin-%s'\n", profileName)
+		fmt.Println("  - Navigate to https://linkedin.com/login")
+		fmt.Println("  - Wait for manual login")
+		fmt.Println("  - Save profile configuration")
+		return
+	}
+	
+	// Start instance
+	pinchTabProfile := fmt.Sprintf("linkedin-%s", profileName)
+	fmt.Println("Starting browser instance...")
+	instance, err := client.StartInstance(pinchTabProfile)
+	if err != nil {
+		exitWithError("Failed to start PinchTab instance. Is PinchTab running? (%v)", err)
+	}
+	
+	defer func() {
+		fmt.Println("Stopping browser instance...")
+		client.StopInstance(instance.ID)
+	}()
+	
+	// Navigate to login
+	tab, err := client.NewTab(instance.ID, "https://linkedin.com/login")
+	if err != nil {
+		exitWithError("Failed to create tab: %v", err)
+	}
+	
+	fmt.Println("\n========================================")
+	fmt.Println("A browser window has opened.")
+	fmt.Println("Please log in to LinkedIn manually.")
+	fmt.Println("Press Enter when you're logged in...")
+	fmt.Println("========================================\n")
+	
+	os.Stdin.Read(make([]byte, 1))
+	
+	// Verify we're logged in by checking for profile menu
+	text, err := client.GetText(tab.ID)
+	if err != nil {
+		exitWithError("Failed to get page text: %v", err)
+	}
+	
+	if !containsAny(text.Text, []string{"Me", "Messaging", "Notifications"}) {
+		fmt.Println("Warning: Could not verify login. Session may not be saved.")
+		fmt.Println("Please try logging in again.")
+		return
+	}
+	
+	// Save profile
+	profile := &config.Profile{
+		Name:            profileName,
+		PinchTabProfile: pinchTabProfile,
+		CreatedAt:       time.Now(),
+		LastUsed:        time.Now(),
+	}
+	
+	if err := cfg.SaveProfile(profile); err != nil {
+		exitWithError("Failed to save profile: %v", err)
+	}
+	
+	fmt.Printf("\n✓ Profile '%s' authenticated successfully!\n", profileName)
+	fmt.Println("You can now use this profile for automation.")
+}
+
+func containsAny(text string, substrs []string) bool {
+	for _, substr := range substrs {
+		if contains(text, substr) {
+			return true
+		}
+	}
+	return false
+}
+
+func contains(text, substr string) bool {
+	return len(text) > 0 && len(substr) > 0 && 
+		(len(text) > len(substr) && (text[:len(substr)] == substr || 
+		contains(text[1:], substr)))
+}
+```
+
+**Step 3: Create connect command**
+
+Create: `internal/cmd/connect.go`
+
+```go
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/linkedin"
+	"github.com/thaddeus-git/linkedin-cli/internal/pinchtab"
+	"github.com/thaddeus-git/linkedin-cli/internal/ratelimit"
+)
+
+var (
+	connectURL  string
+	connectNote string
+)
+
+func init() {
+	rootCmd.AddCommand(connectCmd)
+	connectCmd.Flags().StringVarP(&connectURL, "url", "u", "", "LinkedIn profile URL (required)")
+	connectCmd.Flags().StringVarP(&connectNote, "message", "m", "", "Connection request note (optional)")
+	connectCmd.MarkFlagRequired("url")
+}
+
+var connectCmd = &cobra.Command{
+	Use:   "connect",
+	Short: "Send a connection request",
+	Long: `Send a connection request to a LinkedIn profile.
+
+Examples:
+  linkedin connect --profile john --url linkedin.com/in/alice
+  linkedin connect --profile john --url linkedin.com/in/alice --message "Hi Alice, loved your post!"
+`,
+	Run: runConnect,
+}
+
+func runConnect(cmd *cobra.Command, args []string) {
+	if profileName == "" {
+		exitWithError("Profile name is required (--profile or LINKEDIN_PROFILE)")
+	}
+	
+	// Validate URL
+	profileURL, err := linkedin.ValidateProfileURL(connectURL)
+	if err != nil {
+		exitWithError("Invalid URL: %v", err)
+	}
+	
+	cfg, err := getConfigManager()
+	if err != nil {
+		exitWithError("Failed to initialize config: %v", err)
+	}
+	
+	// Load profile
+	profile, err := cfg.LoadProfile(profileName)
+	if err != nil {
+		exitWithError("Failed to load profile: %v", err)
+	}
+	
+	// Check rate limits
+	limiter := ratelimit.NewLimiter(profileName, ratelimit.DefaultLimits(), cfg)
+	if err := limiter.CheckConnection(); err != nil {
+		exitWithError("Rate limit check failed: %v", err)
+	}
+	
+	if dryRun {
+		fmt.Println("[dry-run] Would:")
+		fmt.Printf("  - Navigate to: %s\n", profileURL)
+		fmt.Println("  - Click Connect button")
+		if connectNote != "" {
+			fmt.Printf("  - Type note: %s\n", connectNote)
+		}
+		fmt.Println("  - Click Send")
+		return
+	}
+	
+	// Initialize PinchTab client
+	client := pinchtab.NewClient(getPinchTabHost())
+	navigator := linkedin.NewNavigator(client)
+	
+	fmt.Printf("Sending connection request to %s...\n", profileURL)
+	logVerbose("Using profile: %s", profileName)
+	
+	// Start instance
+	logVerbose("Starting PinchTab instance...")
+	instance, err := client.StartInstance(profile.PinchTabProfile)
+	if err != nil {
+		exitWithError("Failed to start PinchTab instance: %v", err)
+	}
+	
+	defer func() {
+		logVerbose("Stopping instance...")
+		client.StopInstance(instance.ID)
+	}()
+	
+	// Create tab and navigate
+	tab, err := client.NewTab(instance.ID, profileURL)
+	if err != nil {
+		exitWithError("Failed to create tab: %v", err)
+	}
+	
+	logVerbose("Navigating to profile...")
+	if err := navigator.NavigateToProfile(tab.ID, profileURL); err != nil {
+		exitWithError("Failed to navigate: %v", err)
+	}
+	
+	// Click connect
+	logVerbose("Clicking Connect button...")
+	if err := navigator.ClickConnect(tab.ID); err != nil {
+		exitWithError("Failed to click connect: %v", err)
+	}
+	
+	// Send with note if provided
+	logVerbose("Sending connection request...")
+	if err := navigator.SendConnectionRequest(tab.ID, connectNote); err != nil {
+		exitWithError("Failed to send request: %v", err)
+	}
+	
+	// Record success
+	if err := limiter.RecordConnection(); err != nil {
+		fmt.Printf("Warning: Failed to record connection: %v\n", err)
+	}
+	
+	// Update last used
+	cfg.UpdateLastUsed(profileName)
+	
+	fmt.Println("✓ Connection request sent successfully!")
+	
+	// Apply rate limiting delay
+	delay := limiter.GetDelay()
+	logVerbose("Waiting %v before exiting...", delay)
+	limiter.Sleep()
+}
+```
+
+**Step 4: Create message command**
+
+Create: `internal/cmd/message.go`
+
+```go
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/linkedin"
+	"github.com/thaddeus-git/linkedin-cli/internal/pinchtab"
+	"github.com/thaddeus-git/linkedin-cli/internal/ratelimit"
+)
+
+var (
+	messageURL     string
+	messageContent string
+)
+
+func init() {
+	rootCmd.AddCommand(messageCmd)
+	messageCmd.Flags().StringVarP(&messageURL, "url", "u", "", "LinkedIn profile URL (required)")
+	messageCmd.Flags().StringVarP(&messageContent, "message", "m", "", "Message content (required)")
+	messageCmd.MarkFlagRequired("url")
+	messageCmd.MarkFlagRequired("message")
+}
+
+var messageCmd = &cobra.Command{
+	Use:   "message",
+	Short: "Send a direct message",
+	Long: `Send a direct message to a LinkedIn connection.
+
+You must already be connected with the recipient.
+
+Examples:
+  linkedin message --profile john --url linkedin.com/in/alice --message "Thanks for connecting!"
+`,
+	Run: runMessage,
+}
+
+func runMessage(cmd *cobra.Command, args []string) {
+	if profileName == "" {
+		exitWithError("Profile name is required (--profile or LINKEDIN_PROFILE)")
+	}
+	
+	// Validate URL
+	profileURL, err := linkedin.ValidateProfileURL(messageURL)
+	if err != nil {
+		exitWithError("Invalid URL: %v", err)
+	}
+	
+	cfg, err := getConfigManager()
+	if err != nil {
+		exitWithError("Failed to initialize config: %v", err)
+	}
+	
+	// Load profile
+	profile, err := cfg.LoadProfile(profileName)
+	if err != nil {
+		exitWithError("Failed to load profile: %v", err)
+	}
+	
+	// Check rate limits
+	limiter := ratelimit.NewLimiter(profileName, ratelimit.DefaultLimits(), cfg)
+	if err := limiter.CheckMessage(); err != nil {
+		exitWithError("Rate limit check failed: %v", err)
+	}
+	
+	if dryRun {
+		fmt.Println("[dry-run] Would:")
+		fmt.Printf("  - Navigate to: %s\n", profileURL)
+		fmt.Println("  - Click Message button")
+		fmt.Printf("  - Type message: %s\n", messageContent)
+		fmt.Println("  - Click Send")
+		return
+	}
+	
+	// Initialize PinchTab client
+	client := pinchtab.NewClient(getPinchTabHost())
+	navigator := linkedin.NewNavigator(client)
+	
+	fmt.Printf("Sending message to %s...\n", profileURL)
+	logVerbose("Using profile: %s", profileName)
+	
+	// Start instance
+	logVerbose("Starting PinchTab instance...")
+	instance, err := client.StartInstance(profile.PinchTabProfile)
+	if err != nil {
+		exitWithError("Failed to start PinchTab instance: %v", err)
+	}
+	
+	defer func() {
+		logVerbose("Stopping instance...")
+		client.StopInstance(instance.ID)
+	}()
+	
+	// Create tab and navigate
+	tab, err := client.NewTab(instance.ID, profileURL)
+	if err != nil {
+		exitWithError("Failed to create tab: %v", err)
+	}
+	
+	logVerbose("Navigating to profile...")
+	if err := navigator.NavigateToProfile(tab.ID, profileURL); err != nil {
+		exitWithError("Failed to navigate: %v", err)
+	}
+	
+	// Open message modal
+	logVerbose("Opening message modal...")
+	if err := navigator.OpenMessageModal(tab.ID); err != nil {
+		exitWithError("Failed to open message modal: %v", err)
+	}
+	
+	// Send message
+	logVerbose("Sending message...")
+	if err := navigator.SendMessage(tab.ID, messageContent); err != nil {
+		exitWithError("Failed to send message: %v", err)
+	}
+	
+	// Record success
+	if err := limiter.RecordMessage(); err != nil {
+		fmt.Printf("Warning: Failed to record message: %v\n", err)
+	}
+	
+	// Update last used
+	cfg.UpdateLastUsed(profileName)
+	
+	fmt.Println("✓ Message sent successfully!")
+	
+	// Apply rate limiting delay
+	delay := limiter.GetDelay()
+	logVerbose("Waiting %v before exiting...", delay)
+	limiter.Sleep()
+}
+```
+
+**Step 5: Create main.go**
+
+Create: `cmd/linkedin/main.go`
+
+```go
+package main
+
+import (
+	"github.com/thaddeus-git/linkedin-cli/internal/cmd"
+)
+
+func main() {
+	cmd.Execute()
+}
+```
+
+**Step 6: Add Cobra dependency**
+
+```bash
+cd /Users/thaddeus/projects/linkedin-cli
+go get github.com/spf13/cobra
+```
+
+**Step 7: Build and test**
+
+```bash
+go build -o linkedin-cli ./cmd/linkedin
+./linkedin-cli --help
+```
+
+Expected: Shows help output with auth, connect, message commands
+
+**Step 8: Commit**
+
+```bash
+git add go.mod go.sum internal/cmd/ cmd/
+git commit -m "feat: add CLI commands (auth, connect, message)"
+```
+
+---
+
+## Task 7: Profiles Subcommand
+
+**Files:**
+- Create: `internal/cmd/profiles.go`
+
+**Step 1: Create profiles command**
+
+Create: `internal/cmd/profiles.go`
+
+```go
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	rootCmd.AddCommand(profilesCmd)
+	profilesCmd.AddCommand(profilesListCmd)
+	profilesCmd.AddCommand(profilesRemoveCmd)
+}
+
+var profilesCmd = &cobra.Command{
+	Use:   "profiles",
+	Short: "Manage LinkedIn profiles",
+	Long:  `List, add, or remove LinkedIn profiles.`,
+}
+
+var profilesListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all profiles",
+	Run:   runProfilesList,
+}
+
+func runProfilesList(cmd *cobra.Command, args []string) {
+	cfg, err := getConfigManager()
+	if err != nil {
+		exitWithError("Failed to initialize config: %v", err)
+	}
+	
+	profiles, err := cfg.ListProfiles()
+	if err != nil {
+		exitWithError("Failed to list profiles: %v", err)
+	}
+	
+	if len(profiles) == 0 {
+		fmt.Println("No profiles found.")
+		fmt.Println("Use 'linkedin auth --profile <name>' to create one.")
+		return
+	}
+	
+	// Load rate limits for status
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	fmt.Fprintln(w, "NAME\tPINCHTAB PROFILE\tLAST USED")
+	
+	for _, name := range profiles {
+		profile, err := cfg.LoadProfile(name)
+		if err != nil {
+			fmt.Fprintf(w, "%s\t<error>\t<error>\n", name)
+			continue
+		}
+		
+		lastUsed := "Never"
+		if !profile.LastUsed.IsZero() {
+			lastUsed = profile.LastUsed.Format("2006-01-02 15:04")
+		}
+		
+		fmt.Fprintf(w, "%s\t%s\t%s\n", profile.Name, profile.PinchTabProfile, lastUsed)
+	}
+	
+	w.Flush()
+	
+	// Show rate limits
+	fmt.Println("\nRate Limits:")
+	for _, name := range profiles {
+		limiter := ratelimit.NewLimiter(name, ratelimit.DefaultLimits(), cfg)
+		status, err := limiter.Status()
+		if err != nil {
+			continue
+		}
+		
+		fmt.Printf("  %s: %d/%d connections today, %d/%d messages today\n",
+			name,
+			status["connections_today"],
+			status["connections_limit"],
+			status["messages_today"],
+			status["messages_limit"],
+		)
+	}
+}
+
+var profilesRemoveCmd = &cobra.Command{
+	Use:   "remove [name]",
+	Short: "Remove a profile",
+	Args:  cobra.ExactArgs(1),
+	Run:   runProfilesRemove,
+}
+
+func runProfilesRemove(cmd *cobra.Command, args []string) {
+	name := args[0]
+	
+	cfg, err := getConfigManager()
+	if err != nil {
+		exitWithError("Failed to initialize config: %v", err)
+	}
+	
+	if !cfg.ProfileExists(name) {
+		exitWithError("Profile '%s' not found", name)
+	}
+	
+	fmt.Printf("Are you sure you want to remove profile '%s'? (y/N): ", name)
+	var response string
+	fmt.Scanln(&response)
+	
+	if response != "y" && response != "Y" {
+		fmt.Println("Cancelled.")
+		return
+	}
+	
+	if err := cfg.DeleteProfile(name); err != nil {
+		exitWithError("Failed to remove profile: %v", err)
+	}
+	
+	fmt.Printf("✓ Profile '%s' removed.\n", name)
+	fmt.Println("Note: The PinchTab browser profile is still saved. Remove it manually if needed.")
+}
+```
+
+**Step 2: Add import**
+
+Edit: `internal/cmd/profiles.go`
+
+Add at imports:
+```go
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/ratelimit"
+)
+```
+
+**Step 3: Test**
+
+```bash
+go build -o linkedin-cli ./cmd/linkedin
+./linkedin-cli profiles list
+./linkedin-cli profiles --help
+```
+
+**Step 4: Commit**
+
+```bash
+git add internal/cmd/profiles.go
+git commit -m "feat: add profiles list and remove commands"
+```
+
+---
+
+## Task 8: Final Polish
+
+**Files:**
+- Modify: `README.md`
+- Create: `Makefile`
+
+**Step 1: Update README**
+
+Replace: `README.md` content
+
+```markdown
+# LinkedIn CLI
+
+A CLI tool for LinkedIn automation using PinchTab. Send connection requests and messages safely with built-in rate limiting.
+
+## Prerequisites
+
+1. **Go 1.21+** - [Install Go](https://go.dev/doc/install)
+2. **PinchTab** - Install and run:
+   ```bash
+   curl -fsSL https://pinchtab.com/install.sh | bash
+   pinchtab  # Keep this running in a separate terminal
+   ```
+
+## Installation
+
+```bash
+go install github.com/thaddeus-git/linkedin-cli/cmd/linkedin@latest
+```
+
+Or build from source:
+
+```bash
+git clone https://github.com/thaddeus-git/linkedin-cli.git
+cd linkedin-cli
+go build -o linkedin-cli ./cmd/linkedin
+mv linkedin-cli $GOPATH/bin/linkedin
+```
+
+## Quick Start
+
+### 1. Authenticate your LinkedIn profile
+
+```bash
+linkedin auth --profile john
+```
+
+This opens a browser window. Log in to LinkedIn manually, then press Enter in the terminal.
+
+### 2. Send a connection request
+
+```bash
+linkedin connect --profile john --url linkedin.com/in/alice
+```
+
+With a personal note:
+
+```bash
+linkedin connect --profile john --url linkedin.com/in/alice \
+  --message "Hi Alice, saw your post about Go concurrency. Would love to connect!"
+```
+
+### 3. Send a direct message
+
+```bash
+linkedin message --profile john --url linkedin.com/in/alice \
+  --message "Thanks for connecting! Looking forward to staying in touch."
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `linkedin auth` | Authenticate a new LinkedIn profile |
+| `linkedin connect` | Send a connection request |
+| `linkedin message` | Send a direct message |
+| `linkedin profiles list` | List authenticated profiles |
+| `linkedin profiles remove` | Remove a profile |
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `LINKEDIN_PROFILE` | Default profile to use | - |
+| `PINCHTAB_HOST` | PinchTab server URL | `http://localhost:9867` |
+
+### Profile Storage
+
+Profiles and rate limits are stored in `~/.linkedin-cli/`:
+
+- `profiles/*.json` - Profile configurations
+- `ratelimit.json` - Rate limit tracking
+
+### Rate Limits
+
+Built-in limits to keep your account safe:
+
+- **Connection requests**: 20/day, 100/week
+- **Messages**: 50/day
+- **Delays**: 3-8 seconds between actions (randomized)
+
+Use `--verbose` to see rate limit status.
+
+## Safety Features
+
+- ✓ Built-in rate limiting
+- ✓ Human-like delays between actions
+- ✓ Dry-run mode (`--dry-run`)
+- ✓ Session persistence (log in once)
+- ✓ LinkedIn profile URL validation
+
+## Examples
+
+### Dry run (test without executing)
+
+```bash
+linkedin connect --profile john --url linkedin.com/in/alice --dry-run
+```
+
+### Verbose output
+
+```bash
+linkedin connect --profile john --url linkedin.com/in/alice --verbose
+```
+
+### Use environment variable for profile
+
+```bash
+export LINKEDIN_PROFILE=john
+linkedin connect --url linkedin.com/in/alice
+```
+
+## Troubleshooting
+
+### "Failed to start PinchTab instance"
+
+Make sure PinchTab is running:
+
+```bash
+pinchtab  # Run in separate terminal
+```
+
+### "Rate limit exceeded"
+
+Wait until the rate limit resets. Check status with:
+
+```bash
+linkedin profiles list
+```
+
+### "Profile not found"
+
+Authenticate first:
+
+```bash
+linkedin auth --profile <name>
+```
+
+## Disclaimer
+
+This tool is for educational and personal use. Using automation on LinkedIn may violate their Terms of Service. Use at your own risk. Start with conservative limits and monitor your account.
+
+## License
+
+MIT
+```
+
+**Step 2: Create Makefile**
+
+Create: `Makefile`
+
+```makefile
+.PHONY: build test clean install lint
+
+BINARY_NAME=linkedin-cli
+MAIN_PACKAGE=./cmd/linkedin
+
+build:
+	go build -o $(BINARY_NAME) $(MAIN_PACKAGE)
+
+test:
+	go test -v ./...
+
+clean:
+	rm -f $(BINARY_NAME)
+	go clean
+
+install: build
+	mv $(BINARY_NAME) $(GOPATH)/bin/linkedin
+
+dev:
+	go run $(MAIN_PACKAGE)
+
+lint:
+	golangci-lint run
+
+fmt:
+	go fmt ./...
+
+deps:
+	go mod download
+	go mod tidy
+```
+
+**Step 3: Final build test**
+
+```bash
+make clean
+make build
+make test
+./linkedin-cli --help
+./linkedin-cli auth --help
+./linkedin-cli connect --help
+./linkedin-cli message --help
+./linkedin-cli profiles --help
+```
+
+**Step 4: Final commit**
+
+```bash
+git add README.md Makefile
+git commit -m "docs: add comprehensive README and Makefile"
+```
+
+---
+
+## Summary
+
+**Completed implementation:**
+
+1. ✅ PinchTab HTTP client (`internal/pinchtab/`)
+2. ✅ Configuration management (`internal/config/`)
+3. ✅ Rate limiting (`internal/ratelimit/`)
+4. ✅ LinkedIn selectors & navigator (`internal/linkedin/`)
+5. ✅ CLI commands (`internal/cmd/`)
+   - `auth` - Authenticate profiles
+   - `connect` - Send connection requests
+   - `message` - Send direct messages
+   - `profiles list/remove` - Manage profiles
+6. ✅ Main entry point (`cmd/linkedin/main.go`)
+7. ✅ Documentation (README, Makefile)
+
+**Next steps:**
+1. Test with real LinkedIn account
+2. Add `queue` command for batch processing
+3. Add more robust error handling for LinkedIn UI changes
+4. Add tests for navigator (requires mocking)
+
+**Plan saved to:** `docs/plans/2025-03-03-linkedin-cli-implementation.md`