linkedin-automation-cli 1.0.0

package/internal/cmd/sequence.go

@@ -0,0 +1,192 @@
+package cmd
+
+import (
+	"encoding/csv"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/linkedin"
+)
+
+var (
+	sequenceURL         string
+	sequenceStep        string
+	sequenceMessage     string
+	sequencePDFURL      string
+	sequenceFile        string
+	sequenceContinue    bool
+	sequenceDefaultStep string
+)
+
+func init() {
+	rootCmd.AddCommand(sequenceCmd)
+	sequenceCmd.Flags().StringVarP(&sequenceURL, "url", "u", "", "LinkedIn profile URL")
+	sequenceCmd.Flags().StringVarP(&sequenceStep, "step", "s", "", "Step: connect|followup|pdf-followup")
+	sequenceCmd.Flags().StringVarP(&sequenceMessage, "message", "m", "", "Message content")
+	sequenceCmd.Flags().StringVar(&sequencePDFURL, "pdf-url", "", "Public PDF URL to include in message")
+	sequenceCmd.Flags().StringVarP(&sequenceFile, "file", "f", "", "CSV file with sequence actions (url,step,message,pdf_url)")
+	sequenceCmd.Flags().BoolVar(&sequenceContinue, "continue-on-error", false, "Continue processing rows after an error")
+	sequenceCmd.Flags().StringVar(&sequenceDefaultStep, "default-step", "", "Default step for CSV rows missing step")
+}
+
+var sequenceCmd = &cobra.Command{
+	Use:   "sequence",
+	Short: "Run repeatable LinkedIn outreach steps",
+	Long: `Run outreach sequence actions for one profile URL or from CSV.
+
+Single target examples:
+  linkedin sequence --profile john --url linkedin.com/in/alice --step connect --message "Hi Alice"
+  linkedin sequence --profile john --url linkedin.com/in/alice --step followup --message "Thanks for accepting"
+  linkedin sequence --profile john --url linkedin.com/in/alice --step pdf-followup --message "Sharing brochure" --pdf-url "https://example.com/brochure.pdf"
+
+Batch example:
+  linkedin sequence --profile john --file sequence.csv --continue-on-error
+
+CSV columns: url,step,message,pdf_url
+`,
+	Run: runSequence,
+}
+
+func runSequence(cmd *cobra.Command, args []string) {
+	ensureProfile()
+
+	if sequenceFile != "" {
+		runSequenceFile()
+		return
+	}
+
+	if sequenceURL == "" || sequenceStep == "" {
+		exitWithError("--url and --step are required for single-target sequence")
+	}
+
+	runSingleSequence(sequenceURL, sequenceStep, sequenceMessage, sequencePDFURL)
+}
+
+func runSequenceFile() {
+	file, err := os.Open(sequenceFile)
+	if err != nil {
+		exitWithError("Failed to open file: %v", err)
+	}
+	defer file.Close()
+
+	reader := csv.NewReader(file)
+	rows, err := reader.ReadAll()
+	if err != nil {
+		exitWithError("Failed to read CSV: %v", err)
+	}
+	if len(rows) == 0 {
+		exitWithError("CSV is empty")
+	}
+
+	headers := make(map[string]int)
+	for i, h := range rows[0] {
+		headers[strings.TrimSpace(strings.ToLower(h))] = i
+	}
+
+	urlIdx, ok := headers["url"]
+	if !ok {
+		exitWithError("CSV must include url column")
+	}
+
+	stepIdx, hasStep := headers["step"]
+	msgIdx, hasMsg := headers["message"]
+	pdfIdx, hasPDF := headers["pdf_url"]
+
+	failed := 0
+	processed := 0
+	for i := 1; i < len(rows); i++ {
+		row := rows[i]
+		if len(row) <= urlIdx {
+			continue
+		}
+
+		url := strings.TrimSpace(row[urlIdx])
+		if url == "" {
+			continue
+		}
+
+		step := sequenceDefaultStep
+		if hasStep && len(row) > stepIdx {
+			cell := strings.TrimSpace(row[stepIdx])
+			if cell != "" {
+				step = cell
+			}
+		}
+
+		message := ""
+		if hasMsg && len(row) > msgIdx {
+			message = strings.TrimSpace(row[msgIdx])
+		}
+
+		pdfURL := ""
+		if hasPDF && len(row) > pdfIdx {
+			pdfURL = strings.TrimSpace(row[pdfIdx])
+		}
+
+		if step == "" {
+			failed++
+			fmt.Printf("[row %d] missing step\n", i+1)
+			if !sequenceContinue {
+				exitWithError("aborting on first error")
+			}
+			continue
+		}
+
+		fmt.Printf("[row %d] %s -> %s\n", i+1, url, step)
+		err = runSingleSequenceErr(url, step, message, pdfURL)
+		if err != nil {
+			failed++
+			fmt.Printf("[row %d] error: %v\n", i+1, err)
+			if !sequenceContinue {
+				exitWithError("aborting on first error")
+			}
+			continue
+		}
+		processed++
+	}
+
+	fmt.Printf("Sequence complete: processed=%d failed=%d\n", processed, failed)
+	if failed > 0 {
+		os.Exit(1)
+	}
+}
+
+func runSingleSequence(url string, step string, message string, pdfURL string) {
+	if err := runSingleSequenceErr(url, step, message, pdfURL); err != nil {
+		exitWithError("sequence failed: %v", err)
+	}
+}
+
+func runSingleSequenceErr(url string, step string, message string, pdfURL string) error {
+	profileURL, err := linkedin.ValidateProfileURL(url)
+	if err != nil {
+		return err
+	}
+
+	normalizedStep := strings.TrimSpace(strings.ToLower(step))
+	switch normalizedStep {
+	case "connect":
+		sendConnectionAction(profileURL, message)
+		return nil
+	case "followup":
+		if strings.TrimSpace(message) == "" {
+			return fmt.Errorf("followup step requires --message")
+		}
+		sendMessageAction(profileURL, message)
+		return nil
+	case "pdf-followup":
+		if strings.TrimSpace(message) == "" {
+			return fmt.Errorf("pdf-followup step requires --message")
+		}
+		full := message
+		if strings.TrimSpace(pdfURL) != "" {
+			full = fmt.Sprintf("%s\n\nPDF: %s", message, pdfURL)
+		}
+		sendMessageAction(profileURL, full)
+		return nil
+	default:
+		return fmt.Errorf("invalid step: %s", step)
+	}
+}

package/internal/config/config.go

@@ -0,0 +1,187 @@
+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)
+}

package/internal/config/config_test.go

@@ -0,0 +1,121 @@
+package config
+
+import (
+	"os"
+	"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",
+		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}
+
+	// Use today's date to ensure the counters don't get reset
+	now := time.Now()
+	limits := &RateLimits{
+		Connections: RateLimit{
+			Today:      15,
+			ThisWeek:   87,
+			LastAction: now,
+		},
+		Messages: RateLimit{
+			Today:      23,
+			LastAction: now,
+		},
+	}
+
+	// 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")
+	}
+}

package/internal/config/profile.go

@@ -0,0 +1,65 @@
+package config
+
+import "time"
+
+// Profile represents a LinkedIn profile configuration
+type Profile struct {
+	Name      string    `json:"name"`
+	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()
+	_, thisWeek := now.ISOWeek()
+	if lastWeek != thisWeek {
+		r.Connections.ThisWeek = 0
+	}
+}