prospect-ai-agent 1.0.0

package/README.md

@@ -0,0 +1,136 @@
+# ProspectAI Desktop Agent
+
+A lightweight CLI that connects to your ProspectAI workspace and runs LinkedIn automation (connect, message, comment, scrape) through a real headless browser. No Chrome extension needed.
+
+Runs on **macOS** and **Windows**. Requires **Node.js 18+**.
+
+## Quick Start
+
+```bash
+# 1. Install
+npm install -g prospect-ai-agent
+
+# 2. Pair with your workspace (get code from Campaigns > Desktop Agent)
+prospect-ai-agent pair <CODE> -s https://your-app-url.com
+
+# 3. One-time LinkedIn login (opens a browser window)
+prospect-ai-agent login
+
+# 4. Start the agent (runs headless in background)
+prospect-ai-agent start
+```
+
+Or run without installing:
+
+```bash
+npx prospect-ai-agent pair <CODE> -s https://your-app-url.com
+npx prospect-ai-agent login
+npx prospect-ai-agent start
+```
+
+## How It Works
+
+```
+ProspectAI Web App (control plane)     Desktop Agent (execution layer)
+┌──────────────────────────────┐       ┌──────────────────────────────┐
+│  Campaigns UI                │       │  CLI (commander)             │
+│  - Create campaigns          │       │  - pair / login / start      │
+│  - Approve AI comments       │       │  - run / status / unpair     │
+│  - View connected agents     │       │                              │
+│                              │       │  Agent Daemon                │
+│  Automation APIs             │ <──── │  - Heartbeat (60s)           │
+│  - GET  /next-job            │       │  - Poll for jobs (5 min)     │
+│  - POST /report              │       │  - Launch headless browser   │
+│  - POST /heartbeat           │       │  - Execute job via Playwright│
+│  - GET/POST /cookies         │       │  - Close browser after task  │
+└──────────────────────────────┘       └──────────────────────────────┘
+```
+
+The agent polls for pending automation jobs, launches a headless Chromium browser only when there's work, executes the task, and closes the browser. Session cookies are encrypted and synced with the server.
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `pair <CODE> -s <URL>` | Pair this device with your ProspectAI workspace |
+| `login` | One-time LinkedIn authentication (opens headed browser) |
+| `start` | Start background daemon (heartbeat + job polling) |
+| `start --interval 10` | Start with custom poll interval (1–30 minutes, default 5) |
+| `run` | Execute one pending job immediately and exit |
+| `status` | Show current device configuration |
+| `unpair` | Disconnect this device and remove local config |
+
+## Supported Job Types
+
+| Type | Description |
+|---|---|
+| `connect` | Send a LinkedIn connection request |
+| `message` | Send a LinkedIn direct message |
+| `scrape_connections` | Sync your LinkedIn connections list |
+| `scrape_posts` | Fetch latest post per prospect (for comment campaigns) |
+| `comment` | Post an approved comment on a LinkedIn post |
+
+## Setup Steps
+
+### 1. Pair with workspace
+
+Generate a pairing code from the **Campaigns** page in ProspectAI (Desktop Agent button), then:
+
+```bash
+prospect-ai-agent pair ABC123 -s https://your-app-url.com
+```
+
+This saves a JWT token and device info to `~/.bluehans-agent/config.json`.
+
+### 2. Authenticate with LinkedIn
+
+```bash
+prospect-ai-agent login
+```
+
+A headed browser opens. Log in to LinkedIn normally. Once you reach the feed, the agent captures your session cookies, encrypts them, and closes the browser. This is a one-time step.
+
+### 3. Start the agent
+
+```bash
+prospect-ai-agent start
+```
+
+The agent runs continuously:
+- Sends heartbeat every 60 seconds
+- Polls for jobs every 5 minutes (configurable with `--interval`)
+- Launches headless Chromium per task, closes after completion
+- Reports results back to ProspectAI
+
+Press **Ctrl+C** to stop.
+
+## Local Data
+
+All data stored in `~/.bluehans-agent/`:
+
+| Path | Contents |
+|---|---|
+| `config.json` | JWT token, device ID, server URL |
+| `cookies.enc` | Encrypted LinkedIn session cookies |
+
+## Troubleshooting
+
+**"Not paired"** — Run `pair` with a fresh code from the app.
+
+**"No cookies available"** — Run `login` to authenticate with LinkedIn.
+
+**Heartbeat failing (401)** — JWT expired (30-day lifespan). Run `unpair` then `pair` again.
+
+**Jobs not executing** — Ensure campaigns are in Active status. Check with `status` command.
+
+## Security
+
+- Agent JWT tokens expire after 30 days; re-pair to renew
+- Revoke any device instantly from ProspectAI Settings
+- LinkedIn cookies are encrypted with AES-256-GCM
+- Only structured job types are executed (no arbitrary code)
+- Browser launches headless and closes after each task
+
+## License
+
+Private — for use with ProspectAI only.

package/dist/agent.js

@@ -0,0 +1,117 @@
+import { ApiClient } from "./api-client.js";
+import { BrowserManager } from "./executor/browser.js";
+import { CookieManager } from "./cookie-manager.js";
+import { executeJob } from "./executor/index.js";
+import { log } from "./logger.js";
+const HEARTBEAT_INTERVAL_MS = 60_000;
+const DEFAULT_POLL_INTERVAL_MIN = 5;
+export class Agent {
+    apiClient;
+    browser;
+    cookieManager;
+    workspaceId;
+    pollIntervalMs;
+    heartbeatTimer = null;
+    pollTimer = null;
+    running = false;
+    executing = false;
+    constructor(options) {
+        this.apiClient = new ApiClient(options.serverUrl, options.token);
+        this.browser = new BrowserManager();
+        this.cookieManager = new CookieManager(options.token);
+        this.workspaceId = options.workspaceId;
+        this.pollIntervalMs =
+            (options.pollIntervalMin ?? DEFAULT_POLL_INTERVAL_MIN) * 60_000;
+    }
+    async start() {
+        this.running = true;
+        const hasCookies = this.cookieManager.loadLocal();
+        if (!hasCookies) {
+            const remote = await this.cookieManager.fetchFromServer(this.apiClient);
+            if (!remote) {
+                log.warn("No LinkedIn cookies found. Run 'login' first to authenticate.");
+            }
+        }
+        await this.apiClient.heartbeat();
+        log.success("Heartbeat sent. Agent is online.");
+        this.heartbeatTimer = setInterval(async () => {
+            if (!this.running)
+                return;
+            const ok = await this.apiClient.heartbeat();
+            if (!ok)
+                log.warn("Heartbeat failed — will retry next interval.");
+        }, HEARTBEAT_INTERVAL_MS);
+        await this.delay(3_000);
+        await this.pollForJob();
+        const intervalMin = this.pollIntervalMs / 60_000;
+        this.pollTimer = setInterval(async () => {
+            if (!this.running)
+                return;
+            await this.pollForJob();
+        }, this.pollIntervalMs);
+        log.success(`Agent is running. Polling every ${intervalMin} min. Browser launches on-demand.`);
+        log.info("Press Ctrl+C to stop.\n");
+    }
+    async runOnce() {
+        log.info("Run-once mode: checking for pending jobs...");
+        await this.apiClient.heartbeat();
+        await this.pollForJob();
+        log.info("Run-once complete.");
+    }
+    async pollForJob() {
+        if (this.executing)
+            return;
+        const job = await this.apiClient.fetchNextJob();
+        if (!job)
+            return;
+        this.executing = true;
+        log.info(`Received job: ${job.type} (${job.id})`);
+        const cookies = await this.cookieManager.getCookies(this.apiClient);
+        if (!cookies || cookies.length === 0) {
+            log.error("No cookies available. Run 'login' to authenticate with LinkedIn.");
+            await this.apiClient.reportJob(job.id, "failed", "No LinkedIn session cookies available");
+            this.executing = false;
+            return;
+        }
+        try {
+            const page = await this.browser.launchForTask(cookies);
+            const result = await executeJob(job, this.browser, this.apiClient, this.workspaceId);
+            const updatedCookies = await this.browser.closeTask();
+            await this.cookieManager.syncAfterTask(this.apiClient, updatedCookies);
+            if (result.success) {
+                await this.apiClient.reportJob(job.id, "done");
+                log.success(`Job ${job.id} completed successfully.`);
+            }
+            else {
+                await this.apiClient.reportJob(job.id, "failed", result.error);
+                log.error(`Job ${job.id} failed: ${result.error}`);
+            }
+        }
+        catch (err) {
+            const message = err.message;
+            await this.apiClient.reportJob(job.id, "failed", message);
+            log.error(`Job ${job.id} threw error: ${message}`);
+            await this.browser.close();
+        }
+        finally {
+            this.executing = false;
+        }
+    }
+    async stop() {
+        log.info("Shutting down agent...");
+        this.running = false;
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        await this.browser.close();
+        log.success("Agent stopped.");
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

package/dist/api-client.js

@@ -0,0 +1,153 @@
+import { log } from "./logger.js";
+export class ApiClient {
+    serverUrl;
+    token;
+    constructor(serverUrl, token = "") {
+        this.serverUrl = serverUrl;
+        this.token = token;
+    }
+    authHeaders() {
+        return {
+            "Content-Type": "application/json",
+            ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
+        };
+    }
+    async pair(code, deviceName, osType, agentVersion) {
+        const res = await fetch(`${this.serverUrl}/api/agent/pair`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code, deviceName, osType, agentVersion }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error ||
+                `Pairing failed (HTTP ${res.status})`);
+        }
+        return (await res.json());
+    }
+    async heartbeat() {
+        try {
+            const res = await fetch(`${this.serverUrl}/api/agent/heartbeat`, {
+                method: "POST",
+                headers: this.authHeaders(),
+            });
+            if (!res.ok) {
+                log.warn(`Heartbeat failed: HTTP ${res.status}`);
+                return false;
+            }
+            return true;
+        }
+        catch (err) {
+            log.warn(`Heartbeat error: ${err.message}`);
+            return false;
+        }
+    }
+    async fetchNextJob() {
+        try {
+            const res = await fetch(`${this.serverUrl}/api/automation/next-job`, {
+                method: "GET",
+                headers: this.authHeaders(),
+            });
+            if (!res.ok) {
+                log.warn(`Next-job request failed: HTTP ${res.status}`);
+                return null;
+            }
+            const data = await res.json();
+            if (!data || !data.id)
+                return null;
+            return data;
+        }
+        catch (err) {
+            log.warn(`Next-job error: ${err.message}`);
+            return null;
+        }
+    }
+    async reportJob(jobId, status, errorMessage) {
+        try {
+            const res = await fetch(`${this.serverUrl}/api/automation/report`, {
+                method: "POST",
+                headers: this.authHeaders(),
+                body: JSON.stringify({ jobId, status, errorMessage }),
+            });
+            if (!res.ok) {
+                log.warn(`Report failed: HTTP ${res.status}`);
+                return false;
+            }
+            return true;
+        }
+        catch (err) {
+            log.warn(`Report error: ${err.message}`);
+            return false;
+        }
+    }
+    async syncConnections(workspaceId, profiles) {
+        try {
+            const res = await fetch(`${this.serverUrl}/api/prospects/sync-connections`, {
+                method: "POST",
+                headers: this.authHeaders(),
+                body: JSON.stringify({ workspaceId, profiles }),
+            });
+            return res.ok;
+        }
+        catch (err) {
+            log.warn(`Sync connections error: ${err.message}`);
+            return false;
+        }
+    }
+    async getCookies() {
+        try {
+            const res = await fetch(`${this.serverUrl}/api/agent/cookies`, {
+                method: "GET",
+                headers: this.authHeaders(),
+            });
+            if (res.status === 404)
+                return null;
+            if (!res.ok) {
+                log.warn(`Get cookies failed: HTTP ${res.status}`);
+                return null;
+            }
+            const data = (await res.json());
+            return data.cookies ?? null;
+        }
+        catch (err) {
+            log.warn(`Get cookies error: ${err.message}`);
+            return null;
+        }
+    }
+    async uploadCookies(encrypted) {
+        try {
+            const res = await fetch(`${this.serverUrl}/api/agent/cookies`, {
+                method: "POST",
+                headers: this.authHeaders(),
+                body: JSON.stringify({ cookies: encrypted }),
+            });
+            if (!res.ok) {
+                log.warn(`Upload cookies failed: HTTP ${res.status}`);
+                return false;
+            }
+            return true;
+        }
+        catch (err) {
+            log.warn(`Upload cookies error: ${err.message}`);
+            return false;
+        }
+    }
+    async submitScrapedPosts(posts, campaignId) {
+        try {
+            const res = await fetch(`${this.serverUrl}/api/agent/scraped-posts`, {
+                method: "POST",
+                headers: this.authHeaders(),
+                body: JSON.stringify({ posts, campaignId }),
+            });
+            if (!res.ok) {
+                log.warn(`Submit scraped posts failed: HTTP ${res.status}`);
+                return false;
+            }
+            return true;
+        }
+        catch (err) {
+            log.warn(`Submit scraped posts error: ${err.message}`);
+            return false;
+        }
+    }
+}

package/dist/config.js

@@ -0,0 +1,39 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CONFIG_DIR = join(homedir(), ".bluehans-agent");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export function getConfigPath() {
+    return CONFIG_FILE;
+}
+export function getBrowserProfileDir() {
+    return join(CONFIG_DIR, "browser-profile");
+}
+export function loadConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return null;
+    try {
+        const raw = readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+export function clearConfig() {
+    if (existsSync(CONFIG_FILE)) {
+        unlinkSync(CONFIG_FILE);
+    }
+}
+export function detectOS() {
+    return process.platform === "darwin" ? "mac" : "windows";
+}

package/dist/cookie-manager.js

@@ -0,0 +1,104 @@
+import { createCipheriv, createDecipheriv, randomBytes, createHash, } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getConfigDir } from "./config.js";
+import { log } from "./logger.js";
+const ALGORITHM = "aes-256-gcm";
+const COOKIE_FILE = "cookies.enc";
+function deriveKey(secret) {
+    return createHash("sha256").update(secret).digest();
+}
+function encrypt(cookies, secret) {
+    const key = deriveKey(secret);
+    const iv = randomBytes(12);
+    const cipher = createCipheriv(ALGORITHM, key, iv);
+    const plaintext = JSON.stringify(cookies);
+    const encrypted = Buffer.concat([
+        cipher.update(plaintext, "utf8"),
+        cipher.final(),
+    ]);
+    const tag = cipher.getAuthTag();
+    return [
+        iv.toString("base64"),
+        tag.toString("base64"),
+        encrypted.toString("base64"),
+    ].join(":");
+}
+function decrypt(data, secret) {
+    const key = deriveKey(secret);
+    const [ivB64, tagB64, dataB64] = data.split(":");
+    if (!ivB64 || !tagB64 || !dataB64)
+        throw new Error("Invalid cookie data");
+    const iv = Buffer.from(ivB64, "base64");
+    const tag = Buffer.from(tagB64, "base64");
+    const ciphertext = Buffer.from(dataB64, "base64");
+    const decipher = createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(tag);
+    const decrypted = Buffer.concat([
+        decipher.update(ciphertext),
+        decipher.final(),
+    ]);
+    return JSON.parse(decrypted.toString("utf8"));
+}
+export class CookieManager {
+    encryptionKey;
+    filePath;
+    constructor(encryptionKey) {
+        this.encryptionKey = encryptionKey;
+        const dir = getConfigDir();
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        this.filePath = join(dir, COOKIE_FILE);
+    }
+    loadLocal() {
+        if (!existsSync(this.filePath))
+            return null;
+        try {
+            const raw = readFileSync(this.filePath, "utf-8");
+            return decrypt(raw, this.encryptionKey);
+        }
+        catch (err) {
+            log.warn(`Failed to load local cookies: ${err.message}`);
+            return null;
+        }
+    }
+    saveLocal(cookies) {
+        const encrypted = encrypt(cookies, this.encryptionKey);
+        writeFileSync(this.filePath, encrypted, "utf-8");
+    }
+    async fetchFromServer(apiClient) {
+        const encrypted = await apiClient.getCookies();
+        if (!encrypted)
+            return null;
+        try {
+            return decrypt(encrypted, this.encryptionKey);
+        }
+        catch (err) {
+            log.warn(`Failed to decrypt server cookies: ${err.message}`);
+            return null;
+        }
+    }
+    async uploadToServer(apiClient, cookies) {
+        const encrypted = encrypt(cookies, this.encryptionKey);
+        await apiClient.uploadCookies(encrypted);
+    }
+    async getCookies(apiClient) {
+        const local = this.loadLocal();
+        if (local && local.length > 0) {
+            log.info("Using locally cached cookies.");
+            return local;
+        }
+        log.info("No local cookies, fetching from server...");
+        const remote = await this.fetchFromServer(apiClient);
+        if (remote && remote.length > 0) {
+            this.saveLocal(remote);
+            log.info("Cookies fetched from server and cached locally.");
+            return remote;
+        }
+        return null;
+    }
+    async syncAfterTask(apiClient, cookies) {
+        this.saveLocal(cookies);
+        await this.uploadToServer(apiClient, cookies);
+    }
+}

package/dist/executor/browser.js

@@ -0,0 +1,89 @@
+import { chromium } from "playwright";
+import { getBrowserProfileDir } from "../config.js";
+import { log } from "../logger.js";
+export class BrowserManager {
+    browser = null;
+    context = null;
+    async launchForTask(cookies) {
+        log.info("Launching headless Chromium for task...");
+        this.browser = await chromium.launch({
+            headless: true,
+            args: [
+                "--disable-blink-features=AutomationControlled",
+                "--no-sandbox",
+            ],
+        });
+        this.context = await this.browser.newContext({
+            viewport: { width: 1280, height: 900 },
+            userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        });
+        if (cookies.length > 0) {
+            await this.context.addCookies(cookies);
+            log.info(`Injected ${cookies.length} cookies.`);
+        }
+        const page = await this.context.newPage();
+        log.success("Headless browser ready.");
+        return page;
+    }
+    async closeTask() {
+        let cookies = [];
+        if (this.context) {
+            const raw = await this.context.cookies();
+            cookies = raw.map((c) => ({
+                name: c.name,
+                value: c.value,
+                domain: c.domain,
+                path: c.path,
+                expires: c.expires,
+                httpOnly: c.httpOnly,
+                secure: c.secure,
+                sameSite: c.sameSite,
+            }));
+            await this.context.close();
+            this.context = null;
+        }
+        if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+        }
+        log.info("Browser closed, cookies extracted.");
+        return cookies;
+    }
+    async launchHeaded() {
+        const userDataDir = getBrowserProfileDir();
+        log.info("Launching headed Chromium for login...");
+        log.info(`Browser profile: ${userDataDir}`);
+        const context = await chromium.launchPersistentContext(userDataDir, {
+            headless: false,
+            viewport: { width: 1280, height: 900 },
+            args: [
+                "--disable-blink-features=AutomationControlled",
+                "--no-sandbox",
+            ],
+        });
+        const pages = context.pages();
+        const page = pages.length > 0 ? pages[0] : await context.newPage();
+        log.success("Headed browser launched.");
+        return { page, context };
+    }
+    async getPage() {
+        if (!this.context) {
+            throw new Error("No browser context — call launchForTask() first");
+        }
+        const pages = this.context.pages();
+        return pages.length > 0 ? pages[0] : await this.context.newPage();
+    }
+    async close() {
+        if (this.context) {
+            await this.context.close();
+            this.context = null;
+        }
+        if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+        }
+    }
+    isRunning() {
+        return this.context !== null;
+    }
+}

package/dist/executor/comment.js

@@ -0,0 +1,49 @@
+import { log } from "../logger.js";
+export async function executeComment(payload, page) {
+    const { postUrl, comment } = payload;
+    if (!postUrl || !comment) {
+        return { success: false, error: "Missing postUrl or comment in payload" };
+    }
+    log.job("comment", `Navigating to post: ${postUrl}`);
+    await page.goto(postUrl, { waitUntil: "domcontentloaded" });
+    await page.waitForTimeout(3000 + Math.random() * 2000);
+    const commentButton = page.locator('button:has-text("Comment"), button[aria-label*="Comment" i], .comment-button').first();
+    const commentBtnVisible = await commentButton.isVisible().catch(() => false);
+    if (commentBtnVisible) {
+        await commentButton.click();
+        await page.waitForTimeout(1500);
+    }
+    const commentBox = page.locator('.ql-editor[data-placeholder*="Add a comment"], .comments-comment-box__form .ql-editor, div[role="textbox"][contenteditable="true"]').first();
+    const boxVisible = await commentBox.isVisible().catch(() => false);
+    if (!boxVisible) {
+        return {
+            success: false,
+            error: "Comment box not found — post may require different interaction",
+        };
+    }
+    await commentBox.click();
+    await page.waitForTimeout(500);
+    await commentBox.fill(comment);
+    await page.waitForTimeout(1000 + Math.random() * 1000);
+    const submitButton = page.locator('button.comments-comment-box__submit-button:not([disabled]), button.comments-comment-box-comment__submit-button:not([disabled]), button:has-text("Comment"):not([disabled])').first();
+    const submitVisible = await submitButton.isVisible().catch(() => false);
+    if (!submitVisible) {
+        return { success: false, error: "Post/Submit button not found or disabled" };
+    }
+    await submitButton.scrollIntoViewIfNeeded();
+    await page.waitForTimeout(500);
+    await submitButton.click();
+    await page.waitForTimeout(3000);
+    const stillVisible = await commentBox.isVisible().catch(() => false);
+    const stillHasText = stillVisible
+        ? await commentBox.evaluate((el) => el.innerText.trim().length > 0)
+        : false;
+    if (stillHasText) {
+        return {
+            success: false,
+            error: "Comment box still has text after submit — button click may have failed",
+        };
+    }
+    log.success(`Comment posted on ${postUrl}`);
+    return { success: true };
+}

package/dist/executor/connect.js

@@ -0,0 +1,58 @@
+import { log } from "../logger.js";
+export async function executeConnect(payload, page) {
+    const { profileUrl, note } = payload;
+    if (!profileUrl) {
+        return { success: false, error: "Missing profileUrl in payload" };
+    }
+    log.job("connect", `Navigating to ${profileUrl}`);
+    await page.goto(profileUrl, { waitUntil: "domcontentloaded" });
+    await page.waitForTimeout(2000 + Math.random() * 2000);
+    // Look for the Connect button — LinkedIn uses several variations
+    const connectButton = page.locator('button:has-text("Connect"), button[aria-label*="connect" i]').first();
+    const isVisible = await connectButton.isVisible().catch(() => false);
+    if (!isVisible) {
+        // Try the "More" dropdown which sometimes hides Connect
+        const moreButton = page.locator('button:has-text("More"), button[aria-label*="more actions" i]').first();
+        if (await moreButton.isVisible().catch(() => false)) {
+            await moreButton.click();
+            await page.waitForTimeout(1000);
+        }
+        const dropdownConnect = page.locator('div[role="listbox"] span:has-text("Connect"), li:has-text("Connect")').first();
+        if (await dropdownConnect.isVisible().catch(() => false)) {
+            await dropdownConnect.click();
+            await page.waitForTimeout(1000);
+        }
+        else {
+            return {
+                success: false,
+                error: "Connect button not found on profile page",
+            };
+        }
+    }
+    else {
+        await connectButton.click();
+        await page.waitForTimeout(1000);
+    }
+    // Handle the "Add a note" modal if a note is provided
+    if (note) {
+        const addNoteButton = page.locator('button:has-text("Add a note")').first();
+        if (await addNoteButton.isVisible().catch(() => false)) {
+            await addNoteButton.click();
+            await page.waitForTimeout(500);
+            const textarea = page.locator('textarea[name="message"], textarea#custom-message').first();
+            if (await textarea.isVisible().catch(() => false)) {
+                await textarea.fill(note);
+                await page.waitForTimeout(500);
+            }
+        }
+    }
+    // Click Send / Send invitation
+    const sendButton = page.locator('button:has-text("Send"), button[aria-label*="Send" i]').first();
+    if (await sendButton.isVisible().catch(() => false)) {
+        await sendButton.click();
+        await page.waitForTimeout(2000);
+        log.success(`Connection request sent to ${profileUrl}`);
+        return { success: true };
+    }
+    return { success: false, error: "Could not click Send button" };
+}

package/dist/executor/index.js

@@ -0,0 +1,25 @@
+import { executeConnect } from "./connect.js";
+import { executeMessage } from "./message.js";
+import { executeScrape } from "./scrape.js";
+import { executeScrapePostsJob } from "./scrape-posts.js";
+import { executeComment } from "./comment.js";
+import { log } from "../logger.js";
+export async function executeJob(job, browser, apiClient, workspaceId) {
+    const page = await browser.getPage();
+    log.info(`Executing job ${job.id} (type: ${job.type})`);
+    switch (job.type) {
+        case "connect":
+            return executeConnect(job.payload, page);
+        case "message":
+            return executeMessage(job.payload, page);
+        case "scrape_connections":
+            return executeScrape(job.payload, page, apiClient, workspaceId);
+        case "scrape_posts":
+            return executeScrapePostsJob(job.payload, page, apiClient, workspaceId);
+        case "comment":
+            return executeComment(job.payload, page);
+        default:
+            log.warn(`Unknown job type: ${job.type}`);
+            return { success: false, error: `Unknown job type: ${job.type}` };
+    }
+}

package/dist/executor/message.js

@@ -0,0 +1,40 @@
+import { log } from "../logger.js";
+export async function executeMessage(payload, page) {
+    const { profileUrl, message } = payload;
+    if (!profileUrl || !message) {
+        return { success: false, error: "Missing profileUrl or message in payload" };
+    }
+    log.job("message", `Navigating to ${profileUrl}`);
+    await page.goto(profileUrl, { waitUntil: "domcontentloaded" });
+    await page.waitForTimeout(2000 + Math.random() * 2000);
+    // Click the Message button on the profile
+    const messageButton = page.locator('button:has-text("Message"), a:has-text("Message")').first();
+    if (!(await messageButton.isVisible().catch(() => false))) {
+        return { success: false, error: "Message button not found on profile page" };
+    }
+    await messageButton.click();
+    await page.waitForTimeout(2000);
+    // Wait for the messaging overlay / compose area
+    const messageBox = page.locator('div[role="textbox"][contenteditable="true"], div.msg-form__contenteditable').first();
+    const boxVisible = await messageBox
+        .waitFor({ state: "visible", timeout: 10000 })
+        .then(() => true)
+        .catch(() => false);
+    if (!boxVisible) {
+        return { success: false, error: "Message compose box not found" };
+    }
+    // Type the message with human-like delay
+    await messageBox.click();
+    await page.waitForTimeout(300);
+    await messageBox.fill(message);
+    await page.waitForTimeout(1000 + Math.random() * 1000);
+    // Click Send
+    const sendButton = page.locator('button:has-text("Send"), button[type="submit"].msg-form__send-button').first();
+    if (!(await sendButton.isVisible().catch(() => false))) {
+        return { success: false, error: "Send button not found in message overlay" };
+    }
+    await sendButton.click();
+    await page.waitForTimeout(2000);
+    log.success(`Message sent to ${profileUrl}`);
+    return { success: true };
+}

package/dist/executor/scrape-posts.js

@@ -0,0 +1,78 @@
+import { log } from "../logger.js";
+export async function executeScrapePostsJob(payload, page, apiClient, workspaceId) {
+    const { prospects, limit = 10, campaignId } = payload;
+    if (!prospects || prospects.length === 0) {
+        return { success: false, error: "No prospects in payload" };
+    }
+    const targets = prospects.slice(0, limit);
+    const scrapedPosts = [];
+    for (let i = 0; i < targets.length; i++) {
+        const prospect = targets[i];
+        const activityUrl = `${prospect.profileUrl.replace(/\/$/, "")}/recent-activity/all/`;
+        log.job("scrape_posts", `[${i + 1}/${targets.length}] Visiting ${activityUrl}`);
+        try {
+            await page.goto(activityUrl, { waitUntil: "domcontentloaded" });
+            await page.waitForTimeout(3000 + Math.random() * 2000);
+            const postData = await page.evaluate(() => {
+                const feedItems = document.querySelectorAll(".feed-shared-update-v2, [data-urn], .occludable-update");
+                for (const item of feedItems) {
+                    const reshareIndicator = item.querySelector(".update-components-mini-update-v2, .feed-shared-reshared-update-v2");
+                    if (reshareIndicator)
+                        continue;
+                    const contentEl = item.querySelector(".feed-shared-update-v2__description, .feed-shared-text, .update-components-text, [dir='ltr']");
+                    const content = contentEl?.textContent?.trim() || "";
+                    if (content.length < 10)
+                        continue;
+                    let postUrl = "";
+                    const urn = item.getAttribute("data-urn");
+                    if (urn) {
+                        const activityId = urn.split(":").pop();
+                        postUrl = `https://www.linkedin.com/feed/update/urn:li:activity:${activityId}/`;
+                    }
+                    if (!postUrl) {
+                        const permalink = item.querySelector('a[href*="/feed/update/"], a[href*="activity"]');
+                        if (permalink)
+                            postUrl = permalink.href.split("?")[0];
+                    }
+                    const authorEl = item.querySelector(".update-components-actor__name span[aria-hidden='true'], .feed-shared-actor__name span");
+                    const postAuthor = authorEl?.textContent?.trim() || "";
+                    const timeEl = item.querySelector(".update-components-actor__sub-description span[aria-hidden='true'], time");
+                    const postTimestamp = timeEl?.textContent?.trim() || "";
+                    return {
+                        postContent: content.slice(0, 2000),
+                        postUrl: postUrl || window.location.href,
+                        postAuthor,
+                        postTimestamp,
+                    };
+                }
+                return null;
+            });
+            if (postData && postData.postContent) {
+                scrapedPosts.push({
+                    prospectId: prospect.id,
+                    ...postData,
+                });
+                log.job("scrape_posts", `Found post for ${prospect.id} (${postData.postContent.slice(0, 80)}...)`);
+            }
+            else {
+                log.warn(`No post found for ${prospect.id}`);
+            }
+        }
+        catch (err) {
+            log.warn(`Error scraping ${prospect.id}: ${err.message}`);
+        }
+        if (i < targets.length - 1) {
+            const delay = 3000 + Math.random() * 2000;
+            await page.waitForTimeout(delay);
+        }
+    }
+    if (scrapedPosts.length === 0) {
+        return { success: false, error: "No posts found for any prospect" };
+    }
+    const submitted = await apiClient.submitScrapedPosts(scrapedPosts, campaignId);
+    if (!submitted) {
+        return { success: false, error: "Failed to submit scraped posts to server" };
+    }
+    log.success(`Scraped ${scrapedPosts.length} posts from ${targets.length} prospects`);
+    return { success: true, count: scrapedPosts.length };
+}

package/dist/executor/scrape.js

@@ -0,0 +1,138 @@
+import { log } from "../logger.js";
+export async function executeScrape(payload, page, apiClient, workspaceId) {
+    const connectionsUrl = "https://www.linkedin.com/mynetwork/invite-connect/connections/";
+    log.job("scrape", "Navigating to LinkedIn connections page...");
+    await page.goto(connectionsUrl, { waitUntil: "domcontentloaded" });
+    await page.waitForTimeout(3000);
+    // Scroll to load all connections
+    log.job("scrape", "Scrolling to load connections...");
+    await scrollToLoadAll(page, 30);
+    // Extract profiles
+    log.job("scrape", "Extracting profiles...");
+    const profiles = await page.evaluate(() => {
+        const results = [];
+        const seen = new Set();
+        const anchors = document.querySelectorAll("a");
+        for (const anchor of anchors) {
+            const href = anchor.getAttribute("href") || "";
+            const match = href.match(/\/in\/([a-zA-Z0-9-]+)/);
+            if (!match)
+                continue;
+            const fullUrl = anchor.href.split("?")[0].replace(/\/$/, "");
+            if (seen.has(fullUrl))
+                continue;
+            if (href.includes("/overlay/") || href.includes("/detail/"))
+                continue;
+            const container = anchor.closest("li") ||
+                anchor.closest("[data-view-name]") ||
+                anchor.closest("div.entity-result") ||
+                anchor.parentElement?.parentElement;
+            if (!container)
+                continue;
+            let fullName = "";
+            const ariaLabel = anchor.getAttribute("aria-label");
+            if (ariaLabel) {
+                fullName = ariaLabel;
+            }
+            if (!fullName) {
+                const hiddenSpan = anchor.querySelector("span[aria-hidden='true']") ||
+                    container.querySelector("span[aria-hidden='true']");
+                if (hiddenSpan)
+                    fullName = hiddenSpan.textContent?.trim() || "";
+            }
+            if (!fullName) {
+                const text = anchor.textContent?.trim() || "";
+                if (text.length > 0 && text.length < 60)
+                    fullName = text;
+            }
+            if (!fullName || fullName.length < 2)
+                continue;
+            fullName = fullName
+                .replace(/^View\s+/i, "")
+                .replace(/('s|'s)\s+profile$/i, "")
+                .trim();
+            let title = "";
+            const candidates = container.querySelectorAll("span, p, div");
+            for (const el of candidates) {
+                const t = el.textContent?.trim() || "";
+                if (t.length > 10 &&
+                    t.length < 120 &&
+                    t !== fullName &&
+                    !t.includes("Connect") &&
+                    !t.includes("Message") &&
+                    !t.includes("ago")) {
+                    title = t;
+                    break;
+                }
+            }
+            const img = container.querySelector("img");
+            const avatarUrl = img?.src || "";
+            let connectedAt = "";
+            const timeEl = container.querySelector("time");
+            if (timeEl) {
+                connectedAt = timeEl.textContent?.trim() || "";
+            }
+            else {
+                const spans = container.querySelectorAll("span, time");
+                for (const el of spans) {
+                    const t = el.textContent?.trim() || "";
+                    if (/ago|day|week|month|year/i.test(t)) {
+                        connectedAt = t;
+                        break;
+                    }
+                }
+            }
+            results.push({ fullName, url: fullUrl, title, avatarUrl, connectedAt });
+            seen.add(fullUrl);
+        }
+        return results;
+    });
+    log.job("scrape", `Extracted ${profiles.length} profiles`);
+    if (profiles.length === 0) {
+        return {
+            success: false,
+            error: "No connections found. You may need to log in to LinkedIn first.",
+        };
+    }
+    // Upload in batches
+    const batchSize = 100;
+    let totalSent = 0;
+    for (let i = 0; i < profiles.length; i += batchSize) {
+        const batch = profiles.slice(i, i + batchSize);
+        const ok = await apiClient.syncConnections(workspaceId, batch);
+        if (ok) {
+            totalSent += batch.length;
+            log.job("scrape", `Uploaded ${totalSent}/${profiles.length}`);
+        }
+        else {
+            log.warn(`Batch upload failed at offset ${i}`);
+        }
+        if (i + batchSize < profiles.length) {
+            await page.waitForTimeout(500);
+        }
+    }
+    log.success(`Scrape complete: ${profiles.length} connections synced`);
+    return { success: true, count: profiles.length };
+}
+async function scrollToLoadAll(page, maxScrolls) {
+    let lastHeight = 0;
+    let noChangeCount = 0;
+    for (let i = 0; i < maxScrolls; i++) {
+        const currentHeight = await page.evaluate(() => document.body.scrollHeight);
+        await page.evaluate(() => window.scrollTo({ top: document.body.scrollHeight, behavior: "smooth" }));
+        const wait = 2000 + Math.random() * 2000;
+        await page.waitForTimeout(wait);
+        if (currentHeight === lastHeight) {
+            noChangeCount++;
+            if (noChangeCount >= 3)
+                break;
+        }
+        else {
+            noChangeCount = 0;
+        }
+        lastHeight = currentHeight;
+        if ((i + 1) % 5 === 0) {
+            log.job("scrape", `Scrolled ${i + 1}/${maxScrolls}...`);
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { hostname } from "node:os";
+import { loadConfig, saveConfig, clearConfig, getConfigPath, detectOS, } from "./config.js";
+import { ApiClient } from "./api-client.js";
+import { Agent } from "./agent.js";
+import { runLogin } from "./login.js";
+import { log } from "./logger.js";
+const VERSION = "1.0.0";
+const DEFAULT_SERVER = "http://localhost:3000";
+const program = new Command();
+program
+    .name("prospect-ai-agent")
+    .description("ProspectAI Desktop Agent — headless browser automation for campaigns")
+    .version(VERSION);
+// ── pair ─────────────────────────────────────────────────────
+program
+    .command("pair")
+    .description("Pair this device with the CRM using a 6-digit code")
+    .argument("<code>", "6-digit pairing code from CRM Settings")
+    .option("-n, --name <name>", "Device name", hostname())
+    .option("-s, --server <url>", "CRM server URL", DEFAULT_SERVER)
+    .action(async (code, opts) => {
+    const existing = loadConfig();
+    if (existing) {
+        log.warn("This device is already paired.");
+        log.info(`Device: ${existing.deviceName}`);
+        log.info(`Workspace: ${existing.workspaceId}`);
+        log.info('Run "unpair" first to re-pair with a different workspace.');
+        process.exit(1);
+    }
+    const osType = detectOS();
+    log.info(`Pairing with code ${code}...`);
+    log.info(`Server: ${opts.server}`);
+    log.info(`Device: ${opts.name} (${osType})`);
+    const client = new ApiClient(opts.server);
+    try {
+        const result = await client.pair(code, opts.name, osType, VERSION);
+        saveConfig({
+            serverUrl: opts.server,
+            token: result.token,
+            deviceId: result.deviceId,
+            workspaceId: result.workspaceId,
+            deviceName: opts.name,
+            osType,
+            pairedAt: new Date().toISOString(),
+        });
+        log.success("Paired successfully!");
+        log.info(`Device ID: ${result.deviceId}`);
+        log.info(`Workspace: ${result.workspaceId}`);
+        log.info(`Config saved to: ${getConfigPath()}`);
+        log.info('\nRun "login" to authenticate with LinkedIn, then "start".');
+    }
+    catch (err) {
+        log.error(`Pairing failed: ${err.message}`);
+        process.exit(1);
+    }
+});
+// ── login ────────────────────────────────────────────────────
+program
+    .command("login")
+    .description("Log in to LinkedIn (opens headed browser, captures cookies for headless use)")
+    .action(async () => {
+    const config = loadConfig();
+    if (!config) {
+        log.error("Not paired. Run 'pair <CODE>' first.");
+        process.exit(1);
+    }
+    await runLogin(config.serverUrl, config.token);
+});
+// ── start ────────────────────────────────────────────────────
+program
+    .command("start")
+    .description("Start the agent daemon (heartbeat + job polling, headless)")
+    .option("-i, --interval <minutes>", "Polling interval in minutes (1-30)", "5")
+    .action(async (opts) => {
+    const config = loadConfig();
+    if (!config) {
+        log.error("Not paired. Run 'pair <CODE>' first.");
+        process.exit(1);
+    }
+    const intervalMin = Math.max(1, Math.min(30, parseInt(opts.interval, 10) || 5));
+    log.info("Starting ProspectAI Desktop Agent...");
+    log.info(`Device: ${config.deviceName} (${config.osType})`);
+    log.info(`Server: ${config.serverUrl}`);
+    log.info(`Workspace: ${config.workspaceId}`);
+    log.info(`Mode: headless (browser launches on-demand)`);
+    log.info(`Poll interval: ${intervalMin} min\n`);
+    const agent = new Agent({
+        serverUrl: config.serverUrl,
+        token: config.token,
+        workspaceId: config.workspaceId,
+        pollIntervalMin: intervalMin,
+    });
+    const shutdown = async () => {
+        await agent.stop();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await agent.start();
+});
+// ── run ──────────────────────────────────────────────────────
+program
+    .command("run")
+    .description("Execute pending jobs immediately (one-shot, then exit)")
+    .action(async () => {
+    const config = loadConfig();
+    if (!config) {
+        log.error("Not paired. Run 'pair <CODE>' first.");
+        process.exit(1);
+    }
+    log.info("ProspectAI Agent — Run Now");
+    log.info(`Server: ${config.serverUrl}`);
+    log.info(`Workspace: ${config.workspaceId}\n`);
+    const agent = new Agent({
+        serverUrl: config.serverUrl,
+        token: config.token,
+        workspaceId: config.workspaceId,
+    });
+    await agent.runOnce();
+    process.exit(0);
+});
+// ── status ───────────────────────────────────────────────────
+program
+    .command("status")
+    .description("Show current agent configuration")
+    .action(() => {
+    const config = loadConfig();
+    if (!config) {
+        log.info("Not paired. No configuration found.");
+        log.info(`Config path: ${getConfigPath()}`);
+        process.exit(0);
+    }
+    console.log("\n  ProspectAI Desktop Agent Status\n");
+    console.log(`  Device Name:  ${config.deviceName}`);
+    console.log(`  OS:           ${config.osType === "mac" ? "macOS" : "Windows"}`);
+    console.log(`  Device ID:    ${config.deviceId}`);
+    console.log(`  Workspace:    ${config.workspaceId}`);
+    console.log(`  Server:       ${config.serverUrl}`);
+    console.log(`  Paired at:    ${config.pairedAt}`);
+    console.log(`  Config file:  ${getConfigPath()}\n`);
+});
+// ── unpair ───────────────────────────────────────────────────
+program
+    .command("unpair")
+    .description("Remove local configuration and unpair this device")
+    .action(() => {
+    const config = loadConfig();
+    if (!config) {
+        log.info("Not paired. Nothing to remove.");
+        process.exit(0);
+    }
+    clearConfig();
+    log.success(`Unpaired device "${config.deviceName}".`);
+    log.info("Note: The device still appears in CRM Settings until revoked there.");
+});
+program.parse();

package/dist/logger.js

@@ -0,0 +1,26 @@
+const RESET = "\x1b[0m";
+const BLUE = "\x1b[34m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const DIM = "\x1b[2m";
+function timestamp() {
+    return new Date().toLocaleTimeString("en-US", { hour12: false });
+}
+export const log = {
+    info(msg) {
+        console.log(`${DIM}${timestamp()}${RESET} ${BLUE}[bluehans]${RESET} ${msg}`);
+    },
+    success(msg) {
+        console.log(`${DIM}${timestamp()}${RESET} ${GREEN}[bluehans]${RESET} ${msg}`);
+    },
+    warn(msg) {
+        console.log(`${DIM}${timestamp()}${RESET} ${YELLOW}[bluehans]${RESET} ${msg}`);
+    },
+    error(msg) {
+        console.error(`${DIM}${timestamp()}${RESET} ${RED}[bluehans]${RESET} ${msg}`);
+    },
+    job(type, msg) {
+        console.log(`${DIM}${timestamp()}${RESET} ${BLUE}[job:${type}]${RESET} ${msg}`);
+    },
+};

package/dist/login.js

@@ -0,0 +1,46 @@
+import { BrowserManager } from "./executor/browser.js";
+import { CookieManager } from "./cookie-manager.js";
+import { ApiClient } from "./api-client.js";
+import { log } from "./logger.js";
+const LINKEDIN_LOGIN_URL = "https://www.linkedin.com/login";
+const LINKEDIN_FEED_PATTERN = /linkedin\.com\/(feed|in\/|mynetwork|messaging)/;
+export async function runLogin(serverUrl, token) {
+    const apiClient = new ApiClient(serverUrl, token);
+    const cookieManager = new CookieManager(token);
+    const browser = new BrowserManager();
+    log.info("Opening LinkedIn login page in headed browser...");
+    log.info("Please log in to your LinkedIn account.\n");
+    const { page, context } = await browser.launchHeaded();
+    await page.goto(LINKEDIN_LOGIN_URL, { waitUntil: "domcontentloaded" });
+    log.info("Waiting for you to complete login...");
+    log.info("(The browser will close automatically once logged in)\n");
+    try {
+        await page.waitForURL(LINKEDIN_FEED_PATTERN, { timeout: 300_000 });
+    }
+    catch {
+        log.error("Login timed out after 5 minutes. Please try again.");
+        await context.close();
+        return;
+    }
+    await page.waitForTimeout(2000);
+    const rawCookies = await context.cookies();
+    const linkedInCookies = rawCookies
+        .filter((c) => c.domain.includes("linkedin.com"))
+        .map((c) => ({
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: c.path,
+        expires: c.expires,
+        httpOnly: c.httpOnly,
+        secure: c.secure,
+        sameSite: c.sameSite,
+    }));
+    log.info(`Captured ${linkedInCookies.length} LinkedIn cookies.`);
+    cookieManager.saveLocal(linkedInCookies);
+    log.success("Cookies saved locally.");
+    await cookieManager.uploadToServer(apiClient, linkedInCookies);
+    log.success("Cookies synced to server.");
+    await context.close();
+    log.success("LinkedIn login complete. You can now run 'start' in headless mode.");
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "prospect-ai-agent",
+  "version": "1.0.0",
+  "description": "ProspectAI Desktop Agent — browser automation for campaigns (no Chrome extension)",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "prospect-ai-agent": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "tsx src/index.ts start",
+    "pair": "tsx src/index.ts pair",
+    "status": "tsx src/index.ts status",
+    "unpair": "tsx src/index.ts unpair",
+    "typecheck": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json",
+    "build:binaries": "npm run build && node build-binaries.mjs",
+    "build:mac": "npm run build && npx pkg dist/index.js --target node18-macos-arm64 --output binaries/prospect-ai-agent-macos --compress GZip",
+    "build:win": "npm run build && npx pkg dist/index.js --target node18-win-x64 --output binaries/prospect-ai-agent-win.exe --compress GZip",
+    "prepublishOnly": "npm run build"
+  },
+  "pkg": {
+    "assets": [
+      "dist/**/*"
+    ],
+    "outputPath": "binaries"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "playwright": "^1.52.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@yao-pkg/pkg": "^6.14.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5"
+  }
+}