linkedin-automation-cli 1.0.0

package/internal/cmd/people.go

@@ -0,0 +1,454 @@
+package cmd
+
+import (
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/pinchtab"
+)
+
+type personCandidate struct {
+	Name           string `json:"name"`
+	Title          string `json:"title"`
+	SourceView     string `json:"source_view"`
+	DiscoveryURL   string `json:"discovery_url"`
+	PublicProfile  string `json:"public_profile_url"`
+	ResolutionNote string `json:"resolution_note,omitempty"`
+}
+
+var (
+	peopleCompanyURL      string
+	peopleMode            string
+	peopleLimit           int
+	peopleFormat          string
+	peopleOutput          string
+	peopleResolveProfiles bool
+)
+
+func init() {
+	rootCmd.AddCommand(peopleCmd)
+	peopleCmd.Flags().StringVar(
+		&peopleCompanyURL,
+		"company-url",
+		"",
+		"LinkedIn company or Sales Navigator company URL",
+	)
+	peopleCmd.Flags().StringVar(
+		&peopleMode,
+		"mode",
+		"both",
+		"Discovery mode: employees|key-persons|both",
+	)
+	peopleCmd.Flags().IntVar(&peopleLimit, "limit", 10, "Maximum people to return")
+	peopleCmd.Flags().StringVar(
+		&peopleFormat,
+		"format",
+		"json",
+		"Output format: json|table|csv",
+	)
+	peopleCmd.Flags().StringVar(&peopleOutput, "output", "", "Write output to file")
+	peopleCmd.Flags().BoolVar(
+		&peopleResolveProfiles,
+		"resolve-free-profile",
+		true,
+		"Open Sales Navigator lead pages to resolve public /in/ URLs",
+	)
+}
+
+var peopleCmd = &cobra.Command{
+	Use:   "people",
+	Short: "Discover company employees/key persons and public profile URLs",
+	Long: `Discover candidate contacts from a company page in LinkedIn/Sales Navigator.
+
+This command focuses on atomic operations:
+- navigate to company page
+- click Employees / Key persons views
+- extract candidate contacts
+- optionally resolve public /in/ URLs from Sales Navigator lead pages
+`,
+	Run: runPeople,
+}
+
+func runPeople(cmd *cobra.Command, args []string) {
+	ensureProfile()
+
+	if strings.TrimSpace(peopleCompanyURL) == "" {
+		exitWithError("--company-url is required")
+	}
+
+	normalizedMode := strings.ToLower(strings.TrimSpace(peopleMode))
+	if normalizedMode != "employees" && normalizedMode != "key-persons" && normalizedMode != "both" {
+		exitWithError("invalid --mode: %s", peopleMode)
+	}
+
+	if peopleLimit <= 0 {
+		exitWithError("--limit must be > 0")
+	}
+
+	normalizedFormat := strings.ToLower(strings.TrimSpace(peopleFormat))
+	if normalizedFormat != "json" && normalizedFormat != "table" && normalizedFormat != "csv" {
+		exitWithError("invalid --format: %s", peopleFormat)
+	}
+
+	if dryRun {
+		fmt.Println("[dry-run] Would:")
+		fmt.Printf("  - Navigate to company URL: %s\n", peopleCompanyURL)
+		fmt.Printf("  - Browse mode: %s\n", normalizedMode)
+		fmt.Printf("  - Extract up to %d contacts\n", peopleLimit)
+		if peopleResolveProfiles {
+			fmt.Println("  - Resolve public /in/ URLs from Sales Navigator lead pages")
+		}
+		return
+	}
+
+	client := pinchtab.NewClient(getPinchTabHost())
+	if err := client.Navigate(peopleCompanyURL); err != nil {
+		exitWithError("failed to navigate to company page: %v", err)
+	}
+	time.Sleep(3 * time.Second)
+
+	views := []string{}
+	if normalizedMode == "employees" || normalizedMode == "both" {
+		views = append(views, "employees")
+	}
+	if normalizedMode == "key-persons" || normalizedMode == "both" {
+		views = append(views, "key-persons")
+	}
+
+	collected := make([]personCandidate, 0, peopleLimit)
+	seen := map[string]bool{}
+
+	for _, view := range views {
+		clicked, clickErr := clickPeopleView(client, view)
+		if clickErr != nil {
+			fmt.Fprintf(os.Stderr, "Warning: failed to click %s view: %v\n", view, clickErr)
+			continue
+		}
+		if clicked {
+			time.Sleep(2 * time.Second)
+		}
+
+		rows, err := extractPeopleCandidates(client, view, peopleLimit)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Warning: failed to extract %s candidates: %v\n", view, err)
+			continue
+		}
+
+		for _, row := range rows {
+			key := strings.ToLower(strings.TrimSpace(row.Name)) + "|" + row.DiscoveryURL
+			if key == "|" || seen[key] {
+				continue
+			}
+			seen[key] = true
+
+			if peopleResolveProfiles && row.PublicProfile == "" && isSalesLeadURL(row.DiscoveryURL) {
+				profileURL, resolveErr := resolvePublicProfileFromLead(client, row.DiscoveryURL)
+				if resolveErr == nil && profileURL != "" {
+					row.PublicProfile = profileURL
+					row.ResolutionNote = "resolved_from_sales_lead"
+				} else if resolveErr != nil {
+					row.ResolutionNote = "resolve_failed"
+				}
+			}
+
+			collected = append(collected, row)
+			if len(collected) >= peopleLimit {
+				break
+			}
+		}
+
+		if len(collected) >= peopleLimit {
+			break
+		}
+	}
+
+	renderPeopleOutput(collected, normalizedFormat, peopleOutput)
+}
+
+func clickPeopleView(client *pinchtab.Client, view string) (bool, error) {
+	terms := "['employee','employees','people']"
+	if view == "key-persons" {
+		terms = "['key person','key persons','key contact','key contacts','decision maker','decision makers','senior']"
+	}
+
+	script := fmt.Sprintf(`(() => {
+  const terms = %s;
+  const nodes = Array.from(document.querySelectorAll('button,a,[role="button"],li,div'));
+  const match = nodes.find((el) => {
+    const text = (el.innerText || el.textContent || '').toLowerCase().trim();
+    if (!text) return false;
+    return terms.some((t) => text.includes(t));
+  });
+  if (!match) return { clicked: false };
+  match.click();
+  return { clicked: true, text: (match.innerText || match.textContent || '').trim() };
+})()`, terms)
+
+	result, err := client.Execute(script)
+	if err != nil {
+		return false, err
+	}
+	obj, ok := result.(map[string]interface{})
+	if !ok {
+		return false, nil
+	}
+	clicked, ok := obj["clicked"].(bool)
+	if !ok {
+		return false, nil
+	}
+	return clicked, nil
+}
+
+func extractPeopleCandidates(client *pinchtab.Client, sourceView string, limit int) ([]personCandidate, error) {
+	script := fmt.Sprintf(`(() => {
+  const MAX = %d;
+  const anchors = Array.from(document.querySelectorAll('a[href]'));
+  const rows = [];
+  const seen = new Set();
+  for (const a of anchors) {
+    const href = (a.href || '').trim();
+    if (!href) continue;
+    const lower = href.toLowerCase();
+    if (!lower.includes('/in/') && !lower.includes('/sales/lead/')) continue;
+
+    let name = (a.innerText || a.textContent || '').trim();
+    if (!name) {
+      const card = a.closest('li,article,div');
+      if (card) {
+        const nameLink = card.querySelector('a[href*="/in/"], a[href*="/sales/lead/"]');
+        if (nameLink) {
+          name = (nameLink.innerText || nameLink.textContent || '').trim();
+        }
+      }
+    }
+    if (!name) continue;
+
+    const key = href.split('?')[0] + '|' + name.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+
+    let title = '';
+    const card = a.closest('li,article,div');
+    if (card) {
+      const textBits = Array.from(card.querySelectorAll('span,div,p'))
+        .map((el) => (el.innerText || '').trim())
+        .filter(Boolean)
+        .filter((t) => t !== name)
+        .filter((t) => t.length < 160);
+      if (textBits.length > 0) {
+        title = textBits[0];
+      }
+    }
+
+    rows.push({
+      name,
+      title,
+      discovery_url: href,
+      public_profile_url: lower.includes('/in/') ? href : ''
+    });
+
+    if (rows.length >= MAX) break;
+  }
+  return rows;
+})()`, limit)
+
+	raw, err := client.Execute(script)
+	if err != nil {
+		return nil, err
+	}
+
+	items, ok := raw.([]interface{})
+	if !ok {
+		return []personCandidate{}, nil
+	}
+
+	results := make([]personCandidate, 0, len(items))
+	for _, item := range items {
+		row, ok := item.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		name := strings.TrimSpace(toString(row["name"]))
+		if name == "" {
+			continue
+		}
+		discoveryURL := strings.TrimSpace(toString(row["discovery_url"]))
+		publicURL := normalizePublicProfileURL(toString(row["public_profile_url"]))
+		if publicURL == "" {
+			publicURL = normalizePublicProfileURL(discoveryURL)
+		}
+
+		results = append(results, personCandidate{
+			Name:          name,
+			Title:         strings.TrimSpace(toString(row["title"])),
+			SourceView:    sourceView,
+			DiscoveryURL:  discoveryURL,
+			PublicProfile: publicURL,
+		})
+	}
+
+	return results, nil
+}
+
+func resolvePublicProfileFromLead(client *pinchtab.Client, leadURL string) (string, error) {
+	if err := client.Navigate(leadURL); err != nil {
+		return "", err
+	}
+	time.Sleep(2 * time.Second)
+
+	raw, err := client.Execute(`(() => {
+  const anchors = Array.from(document.querySelectorAll('a[href]'));
+  for (const a of anchors) {
+    const href = (a.href || '').trim();
+    if (href.toLowerCase().includes('linkedin.com/in/')) {
+      return { profile_url: href };
+    }
+  }
+  const canonical = document.querySelector('link[rel="canonical"]')?.href || '';
+  if (canonical.toLowerCase().includes('linkedin.com/in/')) {
+    return { profile_url: canonical };
+  }
+  return { profile_url: '' };
+})()`)
+	if err != nil {
+		return "", err
+	}
+	obj, ok := raw.(map[string]interface{})
+	if !ok {
+		return "", nil
+	}
+	return normalizePublicProfileURL(toString(obj["profile_url"])), nil
+}
+
+func isSalesLeadURL(value string) bool {
+	return strings.Contains(strings.ToLower(value), "/sales/lead/")
+}
+
+func normalizePublicProfileURL(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+
+	if fromSales := convertSalesLeadURLToPublicProfile(trimmed); fromSales != "" {
+		return fromSales
+	}
+
+	if !strings.Contains(strings.ToLower(trimmed), "linkedin.com/in/") {
+		return ""
+	}
+	base := strings.Split(trimmed, "?")[0]
+	base = strings.Split(base, "#")[0]
+	base = strings.TrimRight(base, "/")
+	return base
+}
+
+func convertSalesLeadURLToPublicProfile(raw string) string {
+	parsed, err := url.Parse(strings.TrimSpace(raw))
+	if err != nil {
+		return ""
+	}
+	host := strings.ToLower(parsed.Host)
+	if host != "" && !strings.Contains(host, "linkedin.com") {
+		return ""
+	}
+
+	path := strings.TrimSpace(parsed.Path)
+	lowerPath := strings.ToLower(path)
+	if !strings.Contains(lowerPath, "/sales/lead/") {
+		return ""
+	}
+
+	parts := strings.Split(path, "/sales/lead/")
+	if len(parts) < 2 {
+		return ""
+	}
+	tail := parts[len(parts)-1]
+	if tail == "" {
+		return ""
+	}
+	memberPart := strings.Split(tail, ",")[0]
+	memberPart = strings.Trim(memberPart, "/")
+	if memberPart == "" {
+		return ""
+	}
+
+	return "https://www.linkedin.com/in/" + memberPart
+}
+
+func toString(value interface{}) string {
+	if value == nil {
+		return ""
+	}
+	if text, ok := value.(string); ok {
+		return text
+	}
+	return fmt.Sprintf("%v", value)
+}
+
+func renderPeopleOutput(rows []personCandidate, format string, outputFile string) {
+	if format == "json" {
+		payload, _ := json.MarshalIndent(rows, "", "  ")
+		writeOrPrint(string(payload), outputFile)
+		return
+	}
+
+	if format == "csv" {
+		builder := &strings.Builder{}
+		writer := csv.NewWriter(builder)
+		_ = writer.Write([]string{"name", "title", "source_view", "discovery_url", "public_profile_url", "resolution_note"})
+		for _, row := range rows {
+			_ = writer.Write([]string{row.Name, row.Title, row.SourceView, row.DiscoveryURL, row.PublicProfile, row.ResolutionNote})
+		}
+		writer.Flush()
+		writeOrPrint(builder.String(), outputFile)
+		return
+	}
+
+	builder := &strings.Builder{}
+	if len(rows) == 0 {
+		builder.WriteString("No people found\n")
+	} else {
+		for _, row := range rows {
+			builder.WriteString(
+				fmt.Sprintf(
+					"%s | %s | %s | %s\n",
+					row.Name,
+					emptyDash(row.Title),
+					emptyDash(row.SourceView),
+					emptyDash(row.PublicProfile),
+				),
+			)
+		}
+	}
+	writeOrPrint(builder.String(), outputFile)
+}
+
+func emptyDash(value string) string {
+	if strings.TrimSpace(value) == "" {
+		return "-"
+	}
+	return value
+}
+
+func writeOrPrint(content string, outputFile string) {
+	if strings.TrimSpace(outputFile) == "" {
+		fmt.Print(content)
+		if !strings.HasSuffix(content, "\n") {
+			fmt.Println()
+		}
+		return
+	}
+
+	if err := os.WriteFile(outputFile, []byte(content), 0644); err != nil {
+		exitWithError("failed to write output: %v", err)
+	}
+	fmt.Printf("Wrote output to %s\n", outputFile)
+}

package/internal/cmd/profiles.go

@@ -0,0 +1,121 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+	"github.com/thaddeus-git/linkedin-cli/internal/ratelimit"
+)
+
+func init() {
+	rootCmd.AddCommand(profilesCmd)
+	profilesCmd.AddCommand(profilesListCmd)
+	profilesCmd.AddCommand(profilesRemoveCmd)
+}
+
+var profilesCmd = &cobra.Command{
+	Use:   "profiles",
+	Short: "Manage LinkedIn profiles",
+	Long:  `List, 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\tLAST USED")
+
+	for _, name := range profiles {
+		profile, err := cfg.LoadProfile(name)
+		if err != nil {
+			fmt.Fprintf(w, "%s\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\n", profile.Name, 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.")
+}

package/internal/cmd/root.go

@@ -0,0 +1,89 @@
+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!"
+
+  # Run sequence step
+  linkedin sequence --profile john --url linkedin.com/in/alice --step connect --message "Hi Alice"
+
+  # Discover contacts from company page
+  linkedin people --profile john --company-url "https://www.linkedin.com/sales/company/123456" --mode both --limit 10
+`,
+}
+
+// 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...)
+	}
+}