linkedin-automation-cli 1.0.0

package/internal/linkedin/navigator.go

@@ -0,0 +1,195 @@
+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(profileURL string) error {
+	if !strings.HasPrefix(profileURL, "http") {
+		profileURL = "https://linkedin.com/in/" + strings.TrimPrefix(profileURL, "/in/")
+	}
+
+	if err := n.client.Navigate(profileURL); err != nil {
+		return fmt.Errorf("failed to navigate: %w", err)
+	}
+
+	time.Sleep(3 * time.Second)
+	return nil
+}
+
+// FindConnectButton finds the connect button in the snapshot
+func (n *Navigator) FindConnectButton(snapshot *pinchtab.Snapshot) (*pinchtab.Node, error) {
+	for i := range snapshot.Nodes {
+		node := &snapshot.Nodes[i]
+		if node.Role == "button" && strings.Contains(strings.ToLower(node.Name), "connect") {
+			return node, 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.Node, error) {
+	for i := range snapshot.Nodes {
+		node := &snapshot.Nodes[i]
+		if node.Role == "button" && strings.Contains(strings.ToLower(node.Name), "message") {
+			return node, nil
+		}
+	}
+
+	return nil, fmt.Errorf("message button not found")
+}
+
+// ClickConnect clicks the connect button
+func (n *Navigator) ClickConnect() error {
+	snapshot, err := n.client.GetSnapshot("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(button.Ref); err != nil {
+		return fmt.Errorf("failed to click connect: %w", err)
+	}
+
+	time.Sleep(2 * time.Second)
+	return nil
+}
+
+// SendConnectionRequest sends a connection request with optional note
+func (n *Navigator) SendConnectionRequest(note string) error {
+	if note != "" {
+		snapshot, err := n.client.GetSnapshot("interactive")
+		if err != nil {
+			return fmt.Errorf("failed to get modal snapshot: %w", err)
+		}
+
+		var textarea *pinchtab.Node
+		for i := range snapshot.Nodes {
+			node := &snapshot.Nodes[i]
+			if node.Role == "textbox" || strings.Contains(strings.ToLower(node.Name), "message") {
+				textarea = node
+				break
+			}
+		}
+
+		if textarea != nil {
+			if err := n.client.HumanType(textarea.Ref, note); err != nil {
+				return fmt.Errorf("failed to type note: %w", err)
+			}
+		}
+	}
+
+	snapshot, err := n.client.GetSnapshot("interactive")
+	if err != nil {
+		return fmt.Errorf("failed to get snapshot for send: %w", err)
+	}
+
+	var sendButton *pinchtab.Node
+	for i := range snapshot.Nodes {
+		node := &snapshot.Nodes[i]
+		if node.Role == "button" && strings.Contains(strings.ToLower(node.Name), "send") {
+			sendButton = node
+			break
+		}
+	}
+
+	if sendButton == nil {
+		return fmt.Errorf("send button not found")
+	}
+
+	if err := n.client.HumanClick(sendButton.Ref); err != nil {
+		return fmt.Errorf("failed to click send: %w", err)
+	}
+
+	return nil
+}
+
+// OpenMessageModal opens the message modal
+func (n *Navigator) OpenMessageModal() error {
+	snapshot, err := n.client.GetSnapshot("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(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(message string) error {
+	snapshot, err := n.client.GetSnapshot("interactive")
+	if err != nil {
+		return fmt.Errorf("failed to get snapshot: %w", err)
+	}
+
+	var textarea *pinchtab.Node
+	for i := range snapshot.Nodes {
+		node := &snapshot.Nodes[i]
+		if node.Role == "textbox" {
+			textarea = node
+			break
+		}
+	}
+
+	if textarea == nil {
+		return fmt.Errorf("message textarea not found")
+	}
+
+	if err := n.client.HumanType(textarea.Ref, message); err != nil {
+		return fmt.Errorf("failed to type message: %w", err)
+	}
+
+	snapshot, err = n.client.GetSnapshot("interactive")
+	if err != nil {
+		return fmt.Errorf("failed to get snapshot for send: %w", err)
+	}
+
+	var sendButton *pinchtab.Node
+	for i := range snapshot.Nodes {
+		node := &snapshot.Nodes[i]
+		if node.Role == "button" && strings.Contains(strings.ToLower(node.Name), "send") {
+			sendButton = node
+			break
+		}
+	}
+
+	if sendButton == nil {
+		return fmt.Errorf("send button not found")
+	}
+
+	if err := n.client.HumanClick(sendButton.Ref); err != nil {
+		return fmt.Errorf("failed to click send: %w", err)
+	}
+
+	return nil
+}

package/internal/linkedin/selectors.go

@@ -0,0 +1,39 @@
+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/']",
+}

package/internal/linkedin/validator.go

@@ -0,0 +1,69 @@
+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 for empty input
+	if input == "" {
+		return "", fmt.Errorf("URL cannot be empty")
+	}
+
+	// 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 ""
+}

package/internal/pinchtab/client.go

@@ -0,0 +1,183 @@
+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,
+		},
+	}
+}
+
+// Navigate navigates the current tab to a URL
+func (c *Client) Navigate(url string) error {
+	reqBody := map[string]string{
+		"url": url,
+	}
+	return c.post("/navigate", reqBody, nil)
+}
+
+// GetSnapshot gets the accessibility tree snapshot
+func (c *Client) GetSnapshot(filter string) (*Snapshot, error) {
+	url := "/snapshot"
+	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 the current tab
+func (c *Client) GetText() (*TextResponse, error) {
+	var resp TextResponse
+	err := c.get("/text", &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(ref string) error {
+	req := ActionRequest{
+		Kind: "click",
+		Ref:  ref,
+	}
+	return c.post("/action", req, nil)
+}
+
+// HumanClick clicks with human-like randomization
+func (c *Client) HumanClick(ref string) error {
+	req := ActionRequest{
+		Kind: "humanClick",
+		Ref:  ref,
+	}
+	return c.post("/action", req, nil)
+}
+
+// Fill fills an input field
+func (c *Client) Fill(ref string, text string) error {
+	req := ActionRequest{
+		Kind: "fill",
+		Ref:  ref,
+		Text: text,
+	}
+	return c.post("/action", req, nil)
+}
+
+// HumanType types with human-like delays
+func (c *Client) HumanType(ref string, text string) error {
+	req := ActionRequest{
+		Kind: "type",
+		Ref:  ref,
+		Text: text,
+	}
+	return c.post("/action", req, nil)
+}
+
+// Execute runs JavaScript in the current tab
+func (c *Client) Execute(expression string) (interface{}, error) {
+	req := map[string]string{
+		"expression": expression,
+	}
+
+	var resp struct {
+		Result interface{} `json:"result"`
+		Error  string      `json:"error,omitempty"`
+	}
+	err := c.post("/evaluate", req, &resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to execute script: %w", err)
+	}
+	if resp.Error != "" {
+		return nil, fmt.Errorf("evaluate error: %s", resp.Error)
+	}
+
+	return resp.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
+}

package/internal/pinchtab/client_test.go

@@ -0,0 +1,67 @@
+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) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/snapshot" {
+			t.Errorf("unexpected path: %s", r.URL.Path)
+		}
+
+		snapshot := Snapshot{
+			URL:   "https://linkedin.com",
+			Title: "LinkedIn",
+			Count: 1,
+			Nodes: []Node{
+				{Ref: "e0", Role: "button", Name: "Connect", Depth: 0, NodeID: 1},
+			},
+		}
+		json.NewEncoder(w).Encode(snapshot)
+	}))
+	defer server.Close()
+
+	client := NewClient(server.URL)
+	snapshot, err := client.GetSnapshot("")
+	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.Nodes) != 1 {
+		t.Errorf("expected 1 node, got %d", len(snapshot.Nodes))
+	}
+}
+
+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("")
+	if err == nil {
+		t.Error("expected error, got nil")
+	}
+}

package/internal/pinchtab/types.go

@@ -0,0 +1,50 @@
+package pinchtab
+
+// Tab represents a browser tab
+type Tab struct {
+	ID    string `json:"id"`
+	URL   string `json:"url"`
+	Title string `json:"title"`
+	Type  string `json:"type"`
+}
+
+// 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"`
+	Count int    `json:"count"`
+	Nodes []Node `json:"nodes"`
+}
+
+// Node represents an accessibility tree node
+type Node struct {
+	Ref    string `json:"ref"`
+	Role   string `json:"role"`
+	Name   string `json:"name"`
+	Depth  int    `json:"depth"`
+	NodeID int    `json:"nodeId"`
+}
+
+// TextResponse represents extracted text
+type TextResponse struct {
+	Text string `json:"text"`
+}