linkedin-automation-cli 1.0.0

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

@@ -0,0 +1,2087 @@
+# 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 and safety features.
+
+**Architecture:** Go CLI using Cobra for commands, with packages for PinchTab HTTP client (`pinchtab/`), LinkedIn-specific selectors (`linkedin/`), rate limiting (`ratelimit/`), and configuration management (`config/`). JSON files for state persistence (no database for v1).
+
+**Tech Stack:** Go 1.21+, Cobra (CLI), standard library for HTTP client, atomic file writes for state management.
+
+---
+
+## Task 1: Project Setup
+
+**Files:**
+- Create: `go.mod`
+- Create: `.gitignore`
+- Create: `README.md` (basic)
+
+**Step 1: Initialize Go module**
+
+```bash
+cd /Users/thaddeus/projects/linkedin-cli
+go mod init github.com/thaddeus-git/linkedin-cli
+```
+
+**Step 2: Install Cobra CLI tool**
+
+```bash
+go install github.com/spf13/cobra-cli@latest
+```
+
+**Step 3: Initialize Cobra project**
+
+```bash
+cobra-cli init --pkg-name github.com/thaddeus-git/linkedin-cli
+```
+
+**Step 4: Create directory structure**
+
+```bash
+mkdir -p internal/{cmd,config,pinchtab,linkedin,ratelimit}
+```
+
+**Step 5: Create .gitignore**
+
+```bash
+cat > .gitignore << 'EOF'
+# Binaries
+linkedin-cli
+*.exe
+*.dll
+*.so
+*.dylib
+
+# Test binary
+*.test
+
+# Output of go coverage
+coverage.out
+
+# Dependency directories
+vendor/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Config/state (user data)
+/.linkedin-cli/
+EOF
+```
+
+**Step 6: Verify build works**
+
+```bash
+go build -o linkedin-cli .
+./linkedin-cli --help
+```
+
+**Expected output:** Shows root command help with "A brief description..."
+
+**Step 7: Commit**
+
+```bash
+git add .
+git commit -m "chore: initialize Go project with Cobra"
+```
+
+---
+
+## Task 2: PinchTab HTTP Client - Core Types
+
+**Files:**
+- Create: `internal/pinchtab/types.go`
+- Create: `internal/pinchtab/types_test.go`
+
+**Step 1: Write types test**
+
+```go
+package pinchtab
+
+import (
+	"testing"
+	"encoding/json"
+)
+
+func TestInstanceResponseSerialization(t *testing.T) {
+	jsonData := `{"id":"inst_abc123","profileId":"test","port":9867,"status":"running"}`
+	var resp InstanceResponse
+	err := json.Unmarshal([]byte(jsonData), &resp)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal: %v", err)
+	}
+	if resp.ID != "inst_abc123" {
+		t.Errorf("Expected ID 'inst_abc123', got '%s'", resp.ID)
+	}
+	if resp.Status != "running" {
+		t.Errorf("Expected status 'running', got '%s'", resp.Status)
+	}
+}
+
+func TestActionRequestSerialization(t *testing.T) {
+	req := ActionRequest{
+		Kind: "click",
+		Ref:  "e5",
+	}
+	data, err := json.Marshal(req)
+	if err != nil {
+		t.Fatalf("Failed to marshal: %v", err)
+	}
+	expected := `{"kind":"click","ref":"e5"}`
+	if string(data) != expected {
+		t.Errorf("Expected '%s', got '%s'", expected, string(data))
+	}
+}
+```
+
+**Step 2: Run test (should fail)**
+
+```bash
+go test ./internal/pinchtab/... -v
+```
+
+**Expected:** FAIL - undefined types
+
+**Step 3: Implement types**
+
+```go
+package pinchtab
+
+// InstanceResponse represents a PinchTab instance
+type InstanceResponse struct {
+	ID        string `json:"id"`
+	ProfileID string `json:"profileId"`
+	Port      int    `json:"port"`
+	Status    string `json:"status"`
+}
+
+// ActionRequest represents an action to perform
+type ActionRequest struct {
+	Kind    string `json:"kind"`
+	Ref     string `json:"ref,omitempty"`
+	Value   string `json:"value,omitempty"`
+	Key     string `json:"key,omitempty"`
+	Amount  int    `json:"amount,omitempty"`
+	URL     string `json:"url,omitempty"`
+}
+
+// SnapshotResponse represents page snapshot
+type SnapshotResponse struct {
+	Title string `json:"title"`
+	URL   string `json:"url"`
+	Elements []Element `json:"elements"`
+}
+
+// Element represents an interactive element
+type Element struct {
+	Ref      string `json:"ref"`
+	Type     string `json:"type"`
+	Text     string `json:"text"`
+	Selector string `json:"selector,omitempty"`
+}
+
+// TextResponse represents extracted text
+type TextResponse struct {
+	Text string `json:"text"`
+}
+```
+
+**Step 4: Run test (should pass)**
+
+```bash
+go test ./internal/pinchtab/... -v
+```
+
+**Expected:** PASS
+
+**Step 5: Commit**
+
+```bash
+git add .
+git commit -m "feat(pinchtab): add core data types"
+```
+
+---
+
+## Task 3: PinchTab HTTP Client - Client Implementation
+
+**Files:**
+- Create: `internal/pinchtab/client.go`
+- Create: `internal/pinchtab/client_test.go`
+
+**Step 1: Write client test**
+
+```go
+package pinchtab
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestClientStartInstance(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/instances" {
+			t.Errorf("Expected path '/instances', got '%s'", r.URL.Path)
+		}
+		if r.Method != "POST" {
+			t.Errorf("Expected POST, got '%s'", r.Method)
+		}
+		
+		resp := InstanceResponse{
+			ID:        "inst_test123",
+			ProfileID: "test-profile",
+			Port:      9867,
+			Status:    "running",
+		}
+		json.NewEncoder(w).Encode(resp)
+	}))
+	defer server.Close()
+	
+	client := NewClient(server.URL)
+	instance, err := client.StartInstance("test-profile")
+	if err != nil {
+		t.Fatalf("StartInstance failed: %v", err)
+	}
+	if instance.ID != "inst_test123" {
+		t.Errorf("Expected ID 'inst_test123', got '%s'", instance.ID)
+	}
+}
+
+func TestClientNavigate(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/instances/test-tab/navigate" {
+			t.Errorf("Expected navigate path, got '%s'", r.URL.Path)
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+	
+	client := NewClient(server.URL)
+	err := client.Navigate("test-tab", "https://linkedin.com/in/test")
+	if err != nil {
+		t.Fatalf("Navigate failed: %v", err)
+	}
+}
+```
+
+**Step 2: Run test (should fail)**
+
+```bash
+go test ./internal/pinchtab/... -v
+```
+
+**Expected:** FAIL - undefined functions
+
+**Step 3: Implement client**
+
+```go
+package pinchtab
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+)
+
+// Client is a PinchTab HTTP API client
+type Client struct {
+	BaseURL    string
+	HTTPClient *http.Client
+}
+
+// NewClient creates a new PinchTab client
+func NewClient(baseURL string) *Client {
+	return &Client{
+		BaseURL:    baseURL,
+		HTTPClient: &http.Client{Timeout: 30 * time.Second},
+	}
+}
+
+// StartInstance starts a new PinchTab instance with the given profile
+func (c *Client) StartInstance(profileID string) (*InstanceResponse, error) {
+	reqBody := map[string]string{"profileId": profileID}
+	data, _ := json.Marshal(reqBody)
+	
+	resp, err := c.HTTPClient.Post(
+		c.BaseURL+"/instances",
+		"application/json",
+		bytes.NewReader(data),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to start instance: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("pinchtab error: %s - %s", resp.Status, string(body))
+	}
+	
+	var instance InstanceResponse
+	if err := json.NewDecoder(resp.Body).Decode(&instance); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+	
+	return &instance, nil
+}
+
+// Navigate navigates a tab to a URL
+func (c *Client) Navigate(tabID, url string) error {
+	reqBody := map[string]string{"url": url}
+	data, _ := json.Marshal(reqBody)
+	
+	resp, err := c.HTTPClient.Post(
+		fmt.Sprintf("%s/instances/%s/navigate", c.BaseURL, tabID),
+		"application/json",
+		bytes.NewReader(data),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to navigate: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("pinchtab error: %s - %s", resp.Status, string(body))
+	}
+	
+	return nil
+}
+
+// GetSnapshot gets the page accessibility snapshot
+func (c *Client) GetSnapshot(tabID string) (*SnapshotResponse, error) {
+	resp, err := c.HTTPClient.Get(
+		fmt.Sprintf("%s/instances/%s/snapshot", c.BaseURL, tabID),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get snapshot: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("pinchtab error: %s - %s", resp.Status, string(body))
+	}
+	
+	var snapshot SnapshotResponse
+	if err := json.NewDecoder(resp.Body).Decode(&snapshot); err != nil {
+		return nil, fmt.Errorf("failed to decode snapshot: %w", err)
+	}
+	
+	return &snapshot, nil
+}
+
+// ExecuteAction executes an action on an element
+func (c *Client) ExecuteAction(tabID string, action ActionRequest) error {
+	data, _ := json.Marshal(action)
+	
+	resp, err := c.HTTPClient.Post(
+		fmt.Sprintf("%s/instances/%s/actions", c.BaseURL, tabID),
+		"application/json",
+		bytes.NewReader(data),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to execute action: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("pinchtab error: %s - %s", resp.Status, string(body))
+	}
+	
+	return nil
+}
+
+// ExtractText extracts text from the page
+func (c *Client) ExtractText(tabID string) (*TextResponse, error) {
+	resp, err := c.HTTPClient.Get(
+		fmt.Sprintf("%s/instances/%s/text", c.BaseURL, tabID),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to extract text: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("pinchtab error: %s - %s", resp.Status, string(body))
+	}
+	
+	var textResp TextResponse
+	if err := json.NewDecoder(resp.Body).Decode(&textResp); err != nil {
+		return nil, fmt.Errorf("failed to decode text: %w", err)
+	}
+	
+	return &textResp, nil
+}
+
+// StopInstance stops a PinchTab instance
+func (c *Client) StopInstance(instanceID string) error {
+	req, err := http.NewRequest(http.MethodPost, 
+		fmt.Sprintf("%s/instances/%s/stop", c.BaseURL, instanceID),
+		nil,
+	)
+	if err != nil {
+		return fmt.Errorf("failed to create stop request: %w", err)
+	}
+	
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to stop instance: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("pinchtab error: %s - %s", resp.Status, string(body))
+	}
+	
+	return nil
+}
+```
+
+**Step 4: Run test (should pass)**
+
+```bash
+go test ./internal/pinchtab/... -v
+```
+
+**Expected:** PASS
+
+**Step 5: Commit**
+
+```bash
+git add .
+git commit -m "feat(pinchtab): implement HTTP client"
+```
+
+---
+
+## Task 4: Configuration Management
+
+**Files:**
+- Create: `internal/config/config.go`
+- Create: `internal/config/config_test.go`
+
+**Step 1: Write config test**
+
+```go
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestGetConfigDir(t *testing.T) {
+	dir, err := GetConfigDir()
+	if err != nil {
+		t.Fatalf("GetConfigDir failed: %v", err)
+	}
+	if dir == "" {
+		t.Error("Config dir should not be empty")
+	}
+}
+
+func TestProfileSaveAndLoad(t *testing.T) {
+	// Use temp dir for testing
+	tmpDir := t.TempDir()
+	
+	profile := &Profile{
+		Name:            "test",
+		PinchTabProfile: "linkedin-test",
+	}
+	
+	// Save
+	path := filepath.Join(tmpDir, "test.json")
+	err := profile.Save(path)
+	if err != nil {
+		t.Fatalf("Save failed: %v", err)
+	}
+	
+	// Load
+	loaded, err := LoadProfile(path)
+	if err != nil {
+		t.Fatalf("LoadProfile failed: %v", err)
+	}
+	if loaded.Name != "test" {
+		t.Errorf("Expected name 'test', got '%s'", loaded.Name)
+	}
+}
+```
+
+**Step 2: Run test (should fail)**
+
+```bash
+go test ./internal/config/... -v
+```
+
+**Expected:** FAIL - undefined types
+
+**Step 3: Implement config**
+
+```go
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"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"`
+}
+
+// GetConfigDir returns the configuration directory
+func GetConfigDir() (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("failed to get home directory: %w", err)
+	}
+	return filepath.Join(home, ".linkedin-cli"), nil
+}
+
+// GetProfilesDir returns the profiles directory
+func GetProfilesDir() (string, error) {
+	configDir, err := GetConfigDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(configDir, "profiles"), nil
+}
+
+// ProfilePath returns the path for a profile file
+func ProfilePath(name string) (string, error) {
+	profilesDir, err := GetProfilesDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(profilesDir, name+".json"), nil
+}
+
+// Save writes the profile to disk
+func (p *Profile) Save(path string) error {
+	data, err := json.MarshalIndent(p, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal profile: %w", err)
+	}
+	
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create directory: %w", err)
+	}
+	
+	if err := os.WriteFile(path, data, 0600); err != nil {
+		return fmt.Errorf("failed to write profile: %w", err)
+	}
+	
+	return nil
+}
+
+// LoadProfile loads a profile from disk
+func LoadProfile(path string) (*Profile, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		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 unmarshal profile: %w", err)
+	}
+	
+	return &profile, nil
+}
+
+// ListProfiles returns all available profile names
+func ListProfiles() ([]string, error) {
+	profilesDir, err := GetProfilesDir()
+	if err != nil {
+		return nil, err
+	}
+	
+	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()
+			name = name[:len(name)-5] // Remove .json
+			profiles = append(profiles, name)
+		}
+	}
+	
+	return profiles, nil
+}
+
+// ProfileExists checks if a profile exists
+func ProfileExists(name string) (bool, error) {
+	path, err := ProfilePath(name)
+	if err != nil {
+		return false, err
+	}
+	_, err = os.Stat(path)
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return err == nil, err
+}
+
+// DeleteProfile removes a profile
+func DeleteProfile(name string) error {
+	path, err := ProfilePath(name)
+	if err != nil {
+		return err
+	}
+	if err := os.Remove(path); err != nil {
+		return fmt.Errorf("failed to delete profile: %w", err)
+	}
+	return nil
+}
+```
+
+**Step 4: Run test (should pass)**
+
+```bash
+go test ./internal/config/... -v
+```
+
+**Expected:** PASS
+
+**Step 5: Commit**
+
+```bash
+git add .
+git commit -m "feat(config): add profile management"
+```
+
+---
+
+## Task 5: Rate Limiting
+
+**Files:**
+- Create: `internal/ratelimit/limiter.go`
+- Create: `internal/ratelimit/limiter_test.go`
+
+**Step 1: Write rate limit test**
+
+```go
+package ratelimit
+
+import (
+	"testing"
+	"time"
+)
+
+func TestCheckConnectionLimit(t *testing.T) {
+	rateFile := "/tmp/test_ratellmit.json"
+	limiter := New(rateFile)
+	
+	// Should allow first 20 connections
+	for i := 0; i < 20; i++ {
+		ok, err := limiter.CheckConnection("test-profile")
+		if err != nil {
+			t.Fatalf("CheckConnection failed: %v", err)
+		}
+		if !ok {
+			t.Errorf("Should allow connection %d", i+1)
+		}
+	}
+	
+	// 21st should be blocked
+	ok, err := limiter.CheckConnection("test-profile")
+	if err != nil {
+		t.Fatalf("CheckConnection failed: %v", err)
+	}
+	if ok {
+		t.Error("Should block 21st connection")
+	}
+}
+```
+
+**Step 2: Run test (should fail)**
+
+```bash
+go test ./internal/ratelimit/... -v
+```
+
+**Expected:** FAIL - undefined types
+
+**Step 3: Implement rate limiter**
+
+```go
+package ratelimit
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+// Limits defines rate limits for a profile
+type Limits struct {
+	ConnectionsToday   int       `json:"connections_today"`
+	ConnectionsWeek    int       `json:"connections_week"`
+	MessagesToday      int       `json:"messages_today"`
+	LastConnectionTime time.Time `json:"last_connection_time"`
+	LastMessageTime    time.Time `json:"last_message_time"`
+}
+
+// Limiter manages rate limits for profiles
+type Limiter struct {
+	stateFile string
+	limits    map[string]*Limits
+	mu        sync.RWMutex
+}
+
+// Default limits (LinkedIn-safe)
+const (
+	MaxConnectionsPerDay  = 20
+	MaxConnectionsPerWeek = 100
+	MaxMessagesPerDay     = 50
+)
+
+// New creates a new rate limiter
+func New(stateFile string) *Limiter {
+	return &Limiter{
+		stateFile: stateFile,
+		limits:    make(map[string]*Limits),
+	}
+}
+
+// Load reads rate limit state from disk
+func (l *Limiter) Load() error {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	
+	data, err := os.ReadFile(l.stateFile)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // No state yet
+		}
+		return fmt.Errorf("failed to read rate limit file: %w", err)
+	}
+	
+	if err := json.Unmarshal(data, &l.limits); err != nil {
+		return fmt.Errorf("failed to unmarshal rate limits: %w", err)
+	}
+	
+	return nil
+}
+
+// Save writes rate limit state to disk
+func (l *Limiter) Save() error {
+	l.mu.RLock()
+	data, err := json.MarshalIndent(l.limits, "", "  ")
+	l.mu.RUnlock()
+	
+	if err != nil {
+		return fmt.Errorf("failed to marshal rate limits: %w", err)
+	}
+	
+	dir := filepath.Dir(l.stateFile)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create directory: %w", err)
+	}
+	
+	if err := os.WriteFile(l.stateFile, data, 0600); err != nil {
+		return fmt.Errorf("failed to write rate limits: %w", err)
+	}
+	
+	return nil
+}
+
+// resetIfNeeded resets counters if day/week has changed
+func (l *Limiter) resetIfNeeded(profile string) {
+	limits, exists := l.limits[profile]
+	if !exists {
+		l.limits[profile] = &Limits{}
+		return
+	}
+	
+	now := time.Now()
+	
+	// Reset daily counters if it's a new day
+	if !limits.LastConnectionTime.IsZero() && 
+		limits.LastConnectionTime.YearDay() != now.YearDay() {
+		limits.ConnectionsToday = 0
+		limits.MessagesToday = 0
+	}
+	
+	// Reset weekly counter if it's a new week
+	if !limits.LastConnectionTime.IsZero() {
+		_, lastWeek := limits.LastConnectionTime.ISOWeek()
+		_, thisWeek := now.ISOWeek()
+		if lastWeek != thisWeek {
+			limits.ConnectionsWeek = 0
+		}
+	}
+}
+
+// CheckConnection checks if a connection request is allowed
+func (l *Limiter) CheckConnection(profile string) (bool, error) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	
+	l.resetIfNeeded(profile)
+	limits := l.limits[profile]
+	
+	if limits.ConnectionsToday >= MaxConnectionsPerDay {
+		return false, nil
+	}
+	if limits.ConnectionsWeek >= MaxConnectionsPerWeek {
+		return false, nil
+	}
+	
+	return true, nil
+}
+
+// RecordConnection records a successful connection
+func (l *Limiter) RecordConnection(profile string) error {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	
+	l.resetIfNeeded(profile)
+	limits := l.limits[profile]
+	
+	limits.ConnectionsToday++
+	limits.ConnectionsWeek++
+	limits.LastConnectionTime = time.Now()
+	
+	return l.Save()
+}
+
+// CheckMessage checks if a message is allowed
+func (l *Limiter) CheckMessage(profile string) (bool, error) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	
+	l.resetIfNeeded(profile)
+	limits := l.limits[profile]
+	
+	return limits.MessagesToday < MaxMessagesPerDay, nil
+}
+
+// RecordMessage records a successful message
+func (l *Limiter) RecordMessage(profile string) error {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	
+	l.resetIfNeeded(profile)
+	limits := l.limits[profile]
+	
+	limits.MessagesToday++
+	limits.LastMessageTime = time.Now()
+	
+	return l.Save()
+}
+
+// GetStats returns current usage stats for a profile
+func (l *Limiter) GetStats(profile string) (connectionsToday, connectionsWeek, messagesToday int) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	
+	limits, exists := l.limits[profile]
+	if !exists {
+		return 0, 0, 0
+	}
+	
+	return limits.ConnectionsToday, limits.ConnectionsWeek, limits.MessagesToday
+}
+```
+
+**Step 4: Run test (should pass)**
+
+```bash
+go test ./internal/ratelimit/... -v
+```
+
+**Expected:** PASS
+
+**Step 5: Commit**
+
+```bash
+git add .
+git commit -m "feat(ratelimit): add rate limiting with LinkedIn-safe defaults"
+```
+
+---
+
+## Task 6: LinkedIn Selectors
+
+**Files:**
+- Create: `internal/linkedin/selectors.go`
+- Create: `internal/linkedin/validator.go`
+
+**Step 1: Implement selectors**
+
+```go
+package linkedin
+
+// Element selectors for LinkedIn pages
+// Note: These are fragile and may break when LinkedIn updates their UI
+
+const (
+	// Profile page selectors
+	ConnectButtonText = "Connect"
+	MessageButtonText = "Message"
+	PendingButtonText = "Pending"
+	
+	// Connection modal selectors
+	ConnectModalNoteTextarea = "textarea[name='message']"
+	ConnectModalSendButton   = "button[aria-label='Send now']"
+	
+	// Message page selectors
+	MessageTextarea = "textarea.msg-form__contenteditable"
+	MessageSendButton = "button[type='submit']"
+	
+	// Common selectors (accessibility refs)
+	RefConnectButton = "e0" // This will be dynamic, found via snapshot
+)
+
+// FindElementRef finds an element reference by text content
+// Returns the ref (e.g., "e5") if found, empty string if not found
+func FindElementRef(elements []Element, text string) string {
+	for _, el := range elements {
+		if el.Text == text {
+			return el.Ref
+		}
+	}
+	return ""
+}
+
+// Element represents an interactive element from PinchTab snapshot
+type Element struct {
+	Ref  string `json:"ref"`
+	Type string `json:"type"`
+	Text string `json:"text"`
+}
+```
+
+**Step 2: Implement validator**
+
+```go
+package linkedin
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+)
+
+// ValidateProfileURL checks if a URL is a valid LinkedIn profile URL
+func ValidateProfileURL(input string) error {
+	if !strings.HasPrefix(input, "http") {
+		input = "https://" + input
+	}
+	
+	u, err := url.Parse(input)
+	if err != nil {
+		return fmt.Errorf("invalid URL: %w", err)
+	}
+	
+	// Check domain
+	if !strings.Contains(u.Host, "linkedin.com") {
+		return fmt.Errorf("URL must be a linkedin.com domain")
+	}
+	
+	// Check path patterns
+	path := u.Path
+	validPatterns := []string{
+		"/in/",
+		"/sales/lead/",
+		"/sales/gmail/",
+	}
+	
+	valid := false
+	for _, pattern := range validPatterns {
+		if strings.HasPrefix(path, pattern) {
+			valid = true
+			break
+		}
+	}
+	
+	if !valid {
+		return fmt.Errorf("URL must be a LinkedIn profile URL (e.g., linkedin.com/in/username)")
+	}
+	
+	return nil
+}
+
+// NormalizeProfileURL ensures the URL has the https:// prefix
+func NormalizeProfileURL(input string) string {
+	if !strings.HasPrefix(input, "http") {
+		return "https://" + input
+	}
+	return input
+}
+```
+
+**Step 3: Commit**
+
+```bash
+git add .
+git commit -m "feat(linkedin): add selectors and URL validation"
+```
+
+---
+
+## Task 7: Auth Command
+
+**Files:**
+- Create: `internal/cmd/auth.go`
+- Modify: `cmd/linkedin/main.go` to add auth command
+
+**Step 1: Implement auth command**
+
+```go
+package cmd
+
+import (
+	"fmt"
+	"os"
+	
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/config"
+	"github.com/thaddeus-git/linkedin-cli/internal/pinchtab"
+)
+
+var authCmd = &cobra.Command{
+	Use:   "auth --profile NAME",
+	Short: "Authenticate a LinkedIn profile",
+	Long:  `Creates a new profile and opens LinkedIn for manual authentication.`,
+	RunE:  runAuth,
+}
+
+func init() {
+	authCmd.Flags().String("profile", "", "Profile name (required)")
+	authCmd.MarkFlagRequired("profile")
+	rootCmd.AddCommand(authCmd)
+}
+
+func runAuth(cmd *cobra.Command, args []string) error {
+	profileName, _ := cmd.Flags().GetString("profile")
+	pinchtabHost := os.Getenv("PINCHTAB_HOST")
+	if pinchtabHost == "" {
+		pinchtabHost = "http://localhost:9867"
+	}
+	
+	// Check if PinchTab is running
+	client := pinchtab.NewClient(pinchtabHost)
+	
+	// Create profile config
+	pinchtabProfileName := "linkedin-" + profileName
+	profile := &config.Profile{
+		Name:            profileName,
+		PinchTabProfile: pinchtabProfileName,
+	}
+	
+	profilePath, err := config.ProfilePath(profileName)
+	if err != nil {
+		return fmt.Errorf("failed to get profile path: %w", err)
+	}
+	
+	// Check if profile already exists
+	exists, _ := config.ProfileExists(profileName)
+	if exists {
+		fmt.Printf("Profile '%s' already exists. Overwrite? (y/N): ", profileName)
+		var response string
+		fmt.Scanln(&response)
+		if response != "y" && response != "Y" {
+			fmt.Println("Cancelled.")
+			return nil
+		}
+	}
+	
+	fmt.Printf("Starting LinkedIn authentication for profile '%s'...\n", profileName)
+	fmt.Println("A browser window will open. Please:")
+	fmt.Println("1. Log in to LinkedIn")
+	fmt.Println("2. Complete any 2FA if required")
+	fmt.Println("3. Keep the browser open until you see 'Authentication complete'")
+	
+	// Start instance with headed mode
+	instance, err := client.StartInstance(pinchtabProfileName)
+	if err != nil {
+		return fmt.Errorf("failed to start PinchTab: %w\nMake sure PinchTab is running: pinchtab start", err)
+	}
+	
+	// Navigate to LinkedIn
+	if err := client.Navigate(instance.ID, "https://linkedin.com/login"); err != nil {
+		client.StopInstance(instance.ID)
+		return fmt.Errorf("failed to navigate: %w", err)
+	}
+	
+	fmt.Printf("\nBrowser opened. Waiting for authentication...\n")
+	fmt.Println("Press Enter when you've successfully logged in to LinkedIn:")
+	fmt.Scanln()
+	
+	// Save profile
+	if err := profile.Save(profilePath); err != nil {
+		client.StopInstance(instance.ID)
+		return fmt.Errorf("failed to save profile: %w", err)
+	}
+	
+	// Stop instance
+	if err := client.StopInstance(instance.ID); err != nil {
+		fmt.Fprintf(os.Stderr, "Warning: failed to stop instance: %v\n", err)
+	}
+	
+	fmt.Printf("\n✓ Profile '%s' authenticated successfully!\n", profileName)
+	fmt.Printf("You can now use: linkedin connect --profile %s --url <profile-url>\n", profileName)
+	
+	return nil
+}
+```
+
+**Step 2: Add auth command to main.go**
+
+The Cobra init should auto-register, but ensure `cmd/auth.go` imports are correct.
+
+**Step 3: Test build**
+
+```bash
+go build -o linkedin-cli .
+./linkedin-cli auth --help
+```
+
+**Expected:** Shows auth command help
+
+**Step 4: Commit**
+
+```bash
+git add .
+git commit -m "feat(cmd): add auth command for profile authentication"
+```
+
+---
+
+## Task 8: Connect Command
+
+**Files:**
+- Create: `internal/cmd/connect.go`
+
+**Step 1: Implement connect command**
+
+```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/linkedin"
+	"github.com/thaddeus-git/linkedin-cli/internal/pinchtab"
+	"github.com/thaddeus-git/linkedin-cli/internal/ratelimit"
+)
+
+var connectCmd = &cobra.Command{
+	Use:   "connect --profile NAME --url URL [--message TEXT]",
+	Short: "Send a connection request",
+	Long:  `Sends a LinkedIn connection request to the specified profile URL.`,
+	RunE:  runConnect,
+}
+
+func init() {
+	connectCmd.Flags().String("profile", "", "Profile name (required)")
+	connectCmd.Flags().String("url", "", "LinkedIn profile URL (required)")
+	connectCmd.Flags().String("message", "", "Connection note (optional)")
+	connectCmd.Flags().Bool("dry-run", false, "Show what would be done without executing")
+	connectCmd.Flags().Bool("yes", false, "Skip confirmation prompt")
+	connectCmd.MarkFlagRequired("profile")
+	connectCmd.MarkFlagRequired("url")
+	rootCmd.AddCommand(connectCmd)
+}
+
+func runConnect(cmd *cobra.Command, args []string) error {
+	profileName, _ := cmd.Flags().GetString("profile")
+	url, _ := cmd.Flags().GetString("url")
+	message, _ := cmd.Flags().GetString("message")
+	dryRun, _ := cmd.Flags().GetBool("dry-run")
+	yes, _ := cmd.Flags().GetBool("yes")
+	
+	pinchtabHost := os.Getenv("PINCHTAB_HOST")
+	if pinchtabHost == "" {
+		pinchtabHost = "http://localhost:9867"
+	}
+	
+	// Validate URL
+	if err := linkedin.ValidateProfileURL(url); err != nil {
+		return err
+	}
+	url = linkedin.NormalizeProfileURL(url)
+	
+	// Load profile
+	profilePath, err := config.ProfilePath(profileName)
+	if err != nil {
+		return fmt.Errorf("failed to get profile path: %w", err)
+	}
+	
+	profile, err := config.LoadProfile(profilePath)
+	if err != nil {
+		return fmt.Errorf("failed to load profile '%s': %w\nRun 'linkedin auth --profile %s' first", profileName, err, profileName)
+	}
+	
+	// Initialize rate limiter
+	configDir, _ := config.GetConfigDir()
+	rateLimiter := ratelimit.New(configDir + "/ratelimit.json")
+	rateLimiter.Load()
+	
+	// Check rate limits
+	ok, err := rateLimiter.CheckConnection(profileName)
+	if err != nil {
+		return fmt.Errorf("rate limit check failed: %w", err)
+	}
+	if !ok {
+		return fmt.Errorf("rate limit exceeded: max %d connections per day", ratelimit.MaxConnectionsPerDay)
+	}
+	
+	// Show stats
+	connToday, connWeek, _ := rateLimiter.GetStats(profileName)
+	fmt.Printf("Rate limit: %d/%d connections today, %d/%d this week\n", 
+		connToday, ratelimit.MaxConnectionsPerDay,
+		connWeek, ratelimit.MaxConnectionsPerWeek)
+	
+	if dryRun {
+		fmt.Printf("[DRY-RUN] Would send connection request to %s\n", url)
+		if message != "" {
+			fmt.Printf("[DRY-RUN] With message: %s\n", message)
+		}
+		return nil
+	}
+	
+	// Confirm
+	if !yes {
+		fmt.Printf("Send connection request to %s? (y/N): ", url)
+		var response string
+		fmt.Scanln(&response)
+		if response != "y" && response != "Y" {
+			fmt.Println("Cancelled.")
+			return nil
+		}
+	}
+	
+	// Execute
+	client := pinchtab.NewClient(pinchtabHost)
+	
+	fmt.Println("Starting PinchTab instance...")
+	instance, err := client.StartInstance(profile.PinchTabProfile)
+	if err != nil {
+		return fmt.Errorf("failed to start PinchTab: %w", err)
+	}
+	defer client.StopInstance(instance.ID)
+	
+	fmt.Printf("Navigating to %s...\n", url)
+	if err := client.Navigate(instance.ID, url); err != nil {
+		return fmt.Errorf("failed to navigate: %w", err)
+	}
+	
+	// Wait for page to load
+	time.Sleep(3 * time.Second)
+	
+	// Get snapshot to find Connect button
+	fmt.Println("Finding Connect button...")
+	snapshot, err := client.GetSnapshot(instance.ID)
+	if err != nil {
+		return fmt.Errorf("failed to get snapshot: %w", err)
+	}
+	
+	// Find Connect button by text
+	connectRef := ""
+	for _, el := range snapshot.Elements {
+		if el.Text == linkedin.ConnectButtonText {
+			connectRef = el.Ref
+			break
+		}
+	}
+	
+	if connectRef == "" {
+		return fmt.Errorf("could not find Connect button on page\nThe profile may already be connected, or the page structure changed")
+	}
+	
+	// Click Connect
+	fmt.Println("Clicking Connect button...")
+	err = client.ExecuteAction(instance.ID, pinchtab.ActionRequest{
+		Kind: "humanClick",
+		Ref:  connectRef,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to click Connect: %w", err)
+	}
+	
+	// Wait for modal
+	time.Sleep(2 * time.Second)
+	
+	// If message provided, add it
+	if message != "" {
+		// Get new snapshot for modal
+		snapshot, err = client.GetSnapshot(instance.ID)
+		if err != nil {
+			return fmt.Errorf("failed to get modal snapshot: %w", err)
+		}
+		
+		// Find "Add a note" button
+		addNoteRef := ""
+		for _, el := range snapshot.Elements {
+			if el.Text == "Add a note" {
+				addNoteRef = el.Ref
+				break
+			}
+		}
+		
+		if addNoteRef != "" {
+			fmt.Println("Adding note...")
+			client.ExecuteAction(instance.ID, pinchtab.ActionRequest{
+				Kind: "humanClick",
+				Ref:  addNoteRef,
+			})
+			time.Sleep(1 * time.Second)
+			
+			// Type message
+			// Find textarea
+			snapshot, _ = client.GetSnapshot(instance.ID)
+			var textareaRef string
+			for _, el := range snapshot.Elements {
+				if el.Type == "textbox" {
+					textareaRef = el.Ref
+					break
+				}
+			}
+			
+			if textareaRef != "" {
+				client.ExecuteAction(instance.ID, pinchtab.ActionRequest{
+					Kind:  "humanType",
+					Ref:   textareaRef,
+					Value: message,
+				})
+				time.Sleep(1 * time.Second)
+			}
+		}
+	}
+	
+	// Click Send
+	fmt.Println("Sending connection request...")
+	snapshot, _ = client.GetSnapshot(instance.ID)
+	sendRef := ""
+	for _, el := range snapshot.Elements {
+		if el.Text == "Send" || el.Text == "Send now" {
+			sendRef = el.Ref
+			break
+		}
+	}
+	
+	if sendRef == "" {
+		return fmt.Errorf("could not find Send button")
+	}
+	
+	err = client.ExecuteAction(instance.ID, pinchtab.ActionRequest{
+		Kind: "humanClick",
+		Ref:  sendRef,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to send request: %w", err)
+	}
+	
+	// Record success
+	if err := rateLimiter.RecordConnection(profileName); err != nil {
+		fmt.Fprintf(os.Stderr, "Warning: failed to record rate limit: %v\n", err)
+	}
+	
+	fmt.Println("✓ Connection request sent successfully!")
+	
+	return nil
+}
+```
+
+**Step 2: Test build**
+
+```bash
+go build -o linkedin-cli .
+./linkedin-cli connect --help
+```
+
+**Expected:** Shows connect command help
+
+**Step 3: Commit**
+
+```bash
+git add .
+git commit -m "feat(cmd): add connect command with rate limiting"
+```
+
+---
+
+## Task 9: Message Command
+
+**Files:**
+- Create: `internal/cmd/message.go`
+
+**Step 1: Implement message command (similar pattern to connect)**
+
+```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/linkedin"
+	"github.com/thaddeus-git/linkedin-cli/internal/pinchtab"
+	"github.com/thaddeus-git/linkedin-cli/internal/ratelimit"
+)
+
+var messageCmd = &cobra.Command{
+	Use:   "message --profile NAME --url URL --message TEXT",
+	Short: "Send a direct message",
+	Long:  `Sends a LinkedIn direct message to a connection.`,
+	RunE:  runMessage,
+}
+
+func init() {
+	messageCmd.Flags().String("profile", "", "Profile name (required)")
+	messageCmd.Flags().String("url", "", "LinkedIn profile URL (required)")
+	messageCmd.Flags().String("message", "", "Message text (required)")
+	messageCmd.Flags().Bool("dry-run", false, "Show what would be done without executing")
+	messageCmd.Flags().Bool("yes", false, "Skip confirmation prompt")
+	messageCmd.MarkFlagRequired("profile")
+	messageCmd.MarkFlagRequired("url")
+	messageCmd.MarkFlagRequired("message")
+	rootCmd.AddCommand(messageCmd)
+}
+
+func runMessage(cmd *cobra.Command, args []string) error {
+	profileName, _ := cmd.Flags().GetString("profile")
+	url, _ := cmd.Flags().GetString("url")
+	message, _ := cmd.Flags().GetString("message")
+	dryRun, _ := cmd.Flags().GetBool("dry-run")
+	yes, _ := cmd.Flags().GetBool("yes")
+	
+	pinchtabHost := os.Getenv("PINCHTAB_HOST")
+	if pinchtabHost == "" {
+		pinchtabHost = "http://localhost:9867"
+	}
+	
+	// Validate
+	if err := linkedin.ValidateProfileURL(url); err != nil {
+		return err
+	}
+	url = linkedin.NormalizeProfileURL(url)
+	
+	if len(message) > 3000 {
+		return fmt.Errorf("message too long: max 3000 characters, got %d", len(message))
+	}
+	
+	// Load profile
+	profilePath, err := config.ProfilePath(profileName)
+	if err != nil {
+		return fmt.Errorf("failed to get profile path: %w", err)
+	}
+	
+	profile, err := config.LoadProfile(profilePath)
+	if err != nil {
+		return fmt.Errorf("failed to load profile '%s': %w", profileName, err)
+	}
+	
+	// Rate limiting
+	configDir, _ := config.GetConfigDir()
+	rateLimiter := ratelimit.New(configDir + "/ratelimit.json")
+	rateLimiter.Load()
+	
+	ok, err := rateLimiter.CheckMessage(profileName)
+	if err != nil {
+		return fmt.Errorf("rate limit check failed: %w", err)
+	}
+	if !ok {
+		return fmt.Errorf("rate limit exceeded: max %d messages per day", ratelimit.MaxMessagesPerDay)
+	}
+	
+	_, _, msgToday := rateLimiter.GetStats(profileName)
+	fmt.Printf("Rate limit: %d/%d messages today\n", msgToday, ratelimit.MaxMessagesPerDay)
+	
+	if dryRun {
+		fmt.Printf("[DRY-RUN] Would send message to %s\n", url)
+		fmt.Printf("[DRY-RUN] Message: %s\n", message)
+		return nil
+	}
+	
+	// Confirm
+	if !yes {
+		fmt.Printf("Send message to %s? (y/N): ", url)
+		var response string
+		fmt.Scanln(&response)
+		if response != "y" && response != "Y" {
+			fmt.Println("Cancelled.")
+			return nil
+		}
+	}
+	
+	// Execute
+	client := pinchtab.NewClient(pinchtabHost)
+	
+	fmt.Println("Starting PinchTab instance...")
+	instance, err := client.StartInstance(profile.PinchTabProfile)
+	if err != nil {
+		return fmt.Errorf("failed to start PinchTab: %w", err)
+	}
+	defer client.StopInstance(instance.ID)
+	
+	fmt.Printf("Navigating to %s...\n", url)
+	if err := client.Navigate(instance.ID, url); err != nil {
+		return fmt.Errorf("failed to navigate: %w", err)
+	}
+	
+	time.Sleep(3 * time.Second)
+	
+	// Find Message button
+	fmt.Println("Finding Message button...")
+	snapshot, err := client.GetSnapshot(instance.ID)
+	if err != nil {
+		return fmt.Errorf("failed to get snapshot: %w", err)
+	}
+	
+	messageRef := ""
+	for _, el := range snapshot.Elements {
+		if el.Text == linkedin.MessageButtonText {
+			messageRef = el.Ref
+			break
+		}
+	}
+	
+	if messageRef == "" {
+		return fmt.Errorf("could not find Message button\nYou may not be connected to this profile")
+	}
+	
+	// Click Message
+	fmt.Println("Opening message dialog...")
+	err = client.ExecuteAction(instance.ID, pinchtab.ActionRequest{
+		Kind: "humanClick",
+		Ref:  messageRef,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to click Message: %w", err)
+	}
+	
+	time.Sleep(2 * time.Second)
+	
+	// Type message
+	fmt.Println("Typing message...")
+	snapshot, _ = client.GetSnapshot(instance.ID)
+	var textareaRef string
+	for _, el := range snapshot.Elements {
+		if el.Type == "textbox" || el.Type == "textField" {
+			textareaRef = el.Ref
+			break
+		}
+	}
+	
+	if textareaRef == "" {
+		return fmt.Errorf("could not find message textarea")
+	}
+	
+	err = client.ExecuteAction(instance.ID, pinchtab.ActionRequest{
+		Kind:  "humanType",
+		Ref:   textareaRef,
+		Value: message,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to type message: %w", err)
+	}
+	
+	time.Sleep(1 * time.Second)
+	
+	// Send
+	fmt.Println("Sending message...")
+	snapshot, _ = client.GetSnapshot(instance.ID)
+	sendRef := ""
+	for _, el := range snapshot.Elements {
+		if el.Text == "Send" {
+			sendRef = el.Ref
+			break
+		}
+	}
+	
+	if sendRef == "" {
+		return fmt.Errorf("could not find Send button")
+	}
+	
+	err = client.ExecuteAction(instance.ID, pinchtab.ActionRequest{
+		Kind: "humanClick",
+		Ref:  sendRef,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to send message: %w", err)
+	}
+	
+	// Record
+	if err := rateLimiter.RecordMessage(profileName); err != nil {
+		fmt.Fprintf(os.Stderr, "Warning: failed to record rate limit: %v\n", err)
+	}
+	
+	fmt.Println("✓ Message sent successfully!")
+	
+	return nil
+}
+```
+
+**Step 2: Test build**
+
+```bash
+go build -o linkedin-cli .
+./linkedin-cli message --help
+```
+
+**Step 3: Commit**
+
+```bash
+git add .
+git commit -m "feat(cmd): add message command"
+```
+
+---
+
+## Task 10: Profiles List Command
+
+**Files:**
+- Create: `internal/cmd/profiles.go`
+
+**Step 1: Implement profiles command**
+
+```go
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+	"time"
+	
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/config"
+	"github.com/thaddeus-git/linkedin-cli/internal/ratelimit"
+)
+
+var profilesCmd = &cobra.Command{
+	Use:   "profiles",
+	Short: "Manage LinkedIn profiles",
+	Long:  `List, show, or remove LinkedIn profiles.`,
+}
+
+var profilesListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all profiles",
+	RunE:  runProfilesList,
+}
+
+var profilesRemoveCmd = &cobra.Command{
+	Use:   "remove NAME",
+	Short: "Remove a profile",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runProfilesRemove,
+}
+
+func init() {
+	profilesCmd.AddCommand(profilesListCmd)
+	profilesCmd.AddCommand(profilesRemoveCmd)
+	rootCmd.AddCommand(profilesCmd)
+}
+
+func runProfilesList(cmd *cobra.Command, args []string) error {
+	profiles, err := config.ListProfiles()
+	if err != nil {
+		return fmt.Errorf("failed to list profiles: %w", err)
+	}
+	
+	if len(profiles) == 0 {
+		fmt.Println("No profiles found.")
+		fmt.Println("Create one with: linkedin auth --profile <name>")
+		return nil
+	}
+	
+	// Load rate limits for stats
+	configDir, _ := config.GetConfigDir()
+	rateLimiter := ratelimit.New(configDir + "/ratelimit.json")
+	rateLimiter.Load()
+	
+	// Print table
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	fmt.Fprintln(w, "PROFILE\tPINCHTAB PROFILE\tLAST USED\tCONN TODAY\tMSG TODAY")
+	
+	for _, name := range profiles {
+		profilePath, _ := config.ProfilePath(name)
+		profile, err := config.LoadProfile(profilePath)
+		if err != nil {
+			fmt.Fprintf(w, "%s\t<error loading>\t\t\t\n", name)
+			continue
+		}
+		
+		lastUsed := "never"
+		if !profile.LastUsed.IsZero() {
+			lastUsed = profile.LastUsed.Format("2006-01-02")
+		}
+		
+		connToday, _, msgToday := rateLimiter.GetStats(name)
+		
+		fmt.Fprintf(w, "%s\t%s\t%s\t%d/%d\t%d/%d\n",
+			profile.Name,
+			profile.PinchTabProfile,
+			lastUsed,
+			connToday, ratelimit.MaxConnectionsPerDay,
+			msgToday, ratelimit.MaxMessagesPerDay,
+		)
+	}
+	
+	w.Flush()
+	return nil
+}
+
+func runProfilesRemove(cmd *cobra.Command, args []string) error {
+	name := args[0]
+	
+	exists, err := config.ProfileExists(name)
+	if err != nil {
+		return fmt.Errorf("failed to check profile: %w", err)
+	}
+	if !exists {
+		return fmt.Errorf("profile '%s' does not exist", name)
+	}
+	
+	fmt.Printf("Remove profile '%s'? This cannot be undone. (y/N): ", name)
+	var response string
+	fmt.Scanln(&response)
+	if response != "y" && response != "Y" {
+		fmt.Println("Cancelled.")
+		return nil
+	}
+	
+	if err := config.DeleteProfile(name); err != nil {
+		return fmt.Errorf("failed to remove profile: %w", err)
+	}
+	
+	// Also remove rate limit data
+	// Note: This is optional, data will be cleaned up on next use
+	
+	fmt.Printf("✓ Profile '%s' removed\n", name)
+	return nil
+}
+```
+
+**Step 2: Test build**
+
+```bash
+go build -o linkedin-cli .
+./linkedin-cli profiles list
+```
+
+**Expected:** Shows empty list or existing profiles
+
+**Step 3: Commit**
+
+```bash
+git add .
+git commit -m "feat(cmd): add profiles list and remove commands"
+```
+
+---
+
+## Task 11: Final Integration & Build
+
+**Files:**
+- Modify: `README.md` with complete documentation
+- Create: `Makefile` for convenience
+
+**Step 1: Update README.md**
+
+```markdown
+# LinkedIn CLI
+
+A command-line tool for LinkedIn automation using PinchTab browser automation.
+
+## Features
+
+- **Authentication**: Secure profile-based authentication with session persistence
+- **Connection Requests**: Send connection requests with personalized notes
+- **Direct Messages**: Send messages to your connections
+- **Rate Limiting**: Built-in LinkedIn-safe rate limits (20 connections/day, 50 messages/day)
+- **Safety First**: Dry-run mode, confirmation prompts, and human-like delays
+
+## Prerequisites
+
+1. [PinchTab](https://pinchtab.com) installed and running
+2. Go 1.21+ (for building from source)
+
+## Installation
+
+```bash
+git clone https://github.com/thaddeus-git/linkedin-cli.git
+cd linkedin-cli
+go build -o linkedin-cli .
+sudo mv linkedin-cli /usr/local/bin/
+```
+
+## Quick Start
+
+### 1. Start PinchTab
+
+```bash
+pinchtab
+```
+
+### 2. Authenticate your LinkedIn profile
+
+```bash
+linkedin auth --profile john
+```
+
+This opens a browser for you to log in to LinkedIn. Your session will be saved.
+
+### 3. Send a connection request
+
+```bash
+linkedin connect --profile john \
+  --url https://linkedin.com/in/alice \
+  --message "Hi Alice, saw your post about..."
+```
+
+### 4. Send a message
+
+```bash
+linkedin message --profile john \
+  --url https://linkedin.com/in/alice \
+  --message "Thanks for connecting!"
+```
+
+## Commands
+
+### `auth`
+
+Authenticate a new LinkedIn profile.
+
+```bash
+linkedin auth --profile NAME
+```
+
+### `connect`
+
+Send a connection request.
+
+```bash
+linkedin connect --profile NAME --url URL [--message TEXT] [flags]
+```
+
+Flags:
+- `--profile`: Profile name (required)
+- `--url`: LinkedIn profile URL (required)
+- `--message`: Connection note (optional)
+- `--dry-run`: Show what would be done without executing
+- `--yes`: Skip confirmation prompt
+
+### `message`
+
+Send a direct message.
+
+```bash
+linkedin message --profile NAME --url URL --message TEXT [flags]
+```
+
+Flags:
+- `--profile`: Profile name (required)
+- `--url`: LinkedIn profile URL (required)
+- `--message`: Message text (required)
+- `--dry-run`: Show what would be done without executing
+- `--yes`: Skip confirmation prompt
+
+### `profiles`
+
+Manage profiles.
+
+```bash
+# List all profiles
+linkedin profiles list
+
+# Remove a profile
+linkedin profiles remove NAME
+```
+
+## Configuration
+
+Configuration is stored in `~/.linkedin-cli/`:
+
+- `profiles/`: Profile configurations
+- `ratelimit.json`: Rate limiting state
+
+## Environment Variables
+
+- `PINCHTAB_HOST`: PinchTab server URL (default: `http://localhost:9867`)
+- `LINKEDIN_PROFILE`: Default profile name
+
+## Rate Limits
+
+Built-in LinkedIn-safe limits:
+
+- **Connection requests**: 20 per day, 100 per week
+- **Messages**: 50 per day
+
+These limits reset automatically. The tool tracks usage per profile.
+
+## Safety Features
+
+1. **Dry-run mode**: Preview actions before executing
+2. **Confirmation prompts**: Confirm destructive actions
+3. **Rate limiting**: Prevents exceeding LinkedIn limits
+4. **Human-like delays**: Random delays between actions
+5. **Circuit breaker**: Stops after consecutive failures
+
+## Development
+
+```bash
+# Run tests
+go test ./...
+
+# Build
+go build -o linkedin-cli .
+
+# Install locally
+go install
+```
+
+## License
+
+MIT
+```
+
+**Step 2: Create Makefile**
+
+```makefile
+.PHONY: build test clean install lint
+
+BINARY_NAME=linkedin-cli
+BUILD_DIR=.
+
+build:
+	go build -o $(BUILD_DIR)/$(BINARY_NAME) .
+
+test:
+	go test -v ./...
+
+clean:
+	rm -f $(BUILD_DIR)/$(BINARY_NAME)
+
+install: build
+	sudo cp $(BUILD_DIR)/$(BINARY_NAME) /usr/local/bin/
+
+lint:
+	golangci-lint run
+
+dev:
+	go run . $(ARGS)
+```
+
+**Step 3: Final build and test**
+
+```bash
+make build
+./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 .
+git commit -m "docs: add README and Makefile"
+```
+
+---
+
+## Milestone 1 Complete
+
+The LinkedIn CLI is now ready for personal use. It supports:
+
+- [x] Profile authentication with PinchTab
+- [x] Connection requests with notes
+- [x] Direct messaging
+- [x] Rate limiting (20 conn/day, 50 msg/day)
+- [x] Dry-run mode
+- [x] Profile management
+- [x] Safety confirmations
+
+## Next Steps (Future Milestones)
+
+- **Batch processing**: `linkedin queue` command for CSV import
+- **Multi-user support**: Team management with role-based access
+- **Scheduling**: Time-based campaign execution
+- **Templates**: Message templates with variables
+- **Analytics**: Track acceptance rates, response rates
+- **Web UI**: Browser-based management interface
+- **API server**: HTTP API for external integrations
+
+## Troubleshooting
+
+### "PinchTab not running"
+
+Start PinchTab first:
+```bash
+pinchtab
+```
+
+### "Rate limit exceeded"
+
+Wait for the daily/weekly limit to reset. Check usage with:
+```bash
+linkedin profiles list
+```
+
+### "Could not find Connect button"
+
+LinkedIn may have changed their UI. Try:
+1. Update to latest version
+2. Check if you're already connected
+3. Use `--dry-run` to debug
+
+### Profile not found
+
+Create the profile first:
+```bash
+linkedin auth --profile <name>
+```