linkedin-agent 1.0.0

package/README.md

@@ -0,0 +1,119 @@
+# linkedin-agent
+
+LinkedIn CLI tool for scraping posts, publishing, editing, and deleting — all from your terminal.
+
+## Install
+
+```bash
+npm install -g linkedin-agent
+```
+
+Or run directly:
+
+```bash
+npx linkedin-agent
+```
+
+## Commands
+
+### `get` — Scrape posts
+
+Collects posts and engagement metrics (likes, comments, shares) via browser automation.
+
+```bash
+# Scrape your own posts
+linkedin-agent get
+
+# Scrape a specific profile
+linkedin-agent get -p https://www.linkedin.com/in/someone
+
+# Limit to recent 10 posts
+linkedin-agent get -l 10
+
+# Specify output directory
+linkedin-agent get -o ./data
+```
+
+On first run, a browser window opens for LinkedIn login. The session persists across runs.
+
+Repeated runs on the same day **merge** with existing data (no duplicates).
+
+**Options:**
+| Flag | Description | Default |
+|------|-------------|---------|
+| `-p, --profile <url>` | Target profile URL | Your profile |
+| `-l, --limit <n>` | Max posts to collect | All |
+| `-o, --output <dir>` | Output directory | Current directory |
+| `-m, --max-scrolls <n>` | Max scroll iterations | 100 |
+
+### `auth` — Set up OAuth
+
+Required for `post`, `edit`, and `delete` commands.
+
+```bash
+# Auto: creates a Developer App + OAuth in one step
+linkedin-agent auth
+
+# Manual: use existing app credentials
+linkedin-agent auth --client-id YOUR_ID --client-secret YOUR_SECRET
+```
+
+### `post` — Publish a post
+
+```bash
+# Post inline text
+linkedin-agent post -t "Hello LinkedIn!"
+
+# Post from a file
+linkedin-agent post -f ./post.md
+
+# Post with a link attachment
+linkedin-agent post -t "Check this out" --link https://example.com
+```
+
+### `edit` — Edit a post
+
+```bash
+linkedin-agent edit --id "urn:li:share:123456" -t "Updated content"
+linkedin-agent edit --id "urn:li:share:123456" -f ./updated.md
+```
+
+### `delete` — Delete a post
+
+```bash
+linkedin-agent delete --id "urn:li:share:123456"
+```
+
+## Output Format
+
+`get` saves posts as JSON:
+
+```json
+[
+  {
+    "id": "urn:li:activity:123456",
+    "text": "Post content...",
+    "publishedAt": "2w",
+    "numLikes": 42,
+    "numComments": 5,
+    "numShares": 3,
+    "url": "https://www.linkedin.com/feed/update/urn:li:activity:123456/"
+  }
+]
+```
+
+File naming: `posts_{username}_{date}.json`
+
+## How It Works
+
+- **`get`**: Uses Playwright to open a real browser, intercepts LinkedIn's internal Voyager API responses as you scroll, and extracts post data.
+- **`post/edit/delete`**: Uses LinkedIn's official REST API with OAuth 2.0 authentication.
+
+## Requirements
+
+- Node.js 18+
+- Chromium (auto-installed via Playwright on first run)
+
+## License
+
+ISC

package/dist/auth.js

@@ -0,0 +1,235 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCredentials = loadCredentials;
+exports.authenticate = authenticate;
+exports.refreshAccessToken = refreshAccessToken;
+exports.getValidCredentials = getValidCredentials;
+const crypto = __importStar(require("crypto"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const CREDENTIALS_PATH = path.join(os.homedir(), ".linkedin-agent", "credentials.json");
+const REDIRECT_URI = "http://localhost:3000/callback";
+const SCOPES = "openid profile email w_member_social";
+function httpsPost(url, data, headers) {
+    return new Promise((resolve, reject) => {
+        const urlObj = new URL(url);
+        const req = https.request({
+            hostname: urlObj.hostname,
+            path: urlObj.pathname + urlObj.search,
+            method: "POST",
+            headers: { ...headers, "Content-Length": Buffer.byteLength(data) },
+        }, (res) => {
+            let body = "";
+            res.on("data", (chunk) => (body += chunk));
+            res.on("end", () => resolve({ status: res.statusCode || 0, body }));
+        });
+        req.on("error", reject);
+        req.write(data);
+        req.end();
+    });
+}
+function httpsGet(url, headers) {
+    return new Promise((resolve, reject) => {
+        const urlObj = new URL(url);
+        const req = https.request({
+            hostname: urlObj.hostname,
+            path: urlObj.pathname + urlObj.search,
+            method: "GET",
+            headers,
+        }, (res) => {
+            let body = "";
+            res.on("data", (chunk) => (body += chunk));
+            res.on("end", () => resolve({ status: res.statusCode || 0, body }));
+        });
+        req.on("error", reject);
+        req.end();
+    });
+}
+function saveCredentials(creds) {
+    fs.mkdirSync(path.dirname(CREDENTIALS_PATH), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), { encoding: "utf-8", mode: 0o600 });
+}
+function loadCredentials() {
+    if (!fs.existsSync(CREDENTIALS_PATH))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function authenticate(clientId, clientSecret, openUrlFn) {
+    // 1. Start callback server and wait for authorization code
+    const state = crypto.randomBytes(32).toString("hex");
+    const authCode = await new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url || "", "http://localhost:3000");
+            const code = url.searchParams.get("code");
+            const returnedState = url.searchParams.get("state");
+            const error = url.searchParams.get("error");
+            if (error) {
+                const desc = url.searchParams.get("error_description") || error;
+                res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+                res.end(`Error: ${desc}`);
+                reject(new Error(`OAuth error: ${desc}`));
+                server.close();
+            }
+            else if (code && returnedState === state) {
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("Authentication complete! You can close this window.");
+                resolve(code);
+                server.close();
+            }
+            else if (code) {
+                res.writeHead(403, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("Invalid state parameter.");
+                reject(new Error("OAuth CSRF detected: state mismatch"));
+                server.close();
+            }
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error("OAuth callback timed out after 5 minutes"));
+        }, 5 * 60 * 1000);
+        server.on("close", () => clearTimeout(timeout));
+        server.listen(3000, "127.0.0.1", async () => {
+            const authUrl = "https://www.linkedin.com/oauth/v2/authorization?" +
+                new URLSearchParams({
+                    response_type: "code",
+                    client_id: clientId,
+                    redirect_uri: REDIRECT_URI,
+                    scope: SCOPES,
+                    state,
+                }).toString();
+            console.log("Opening browser for LinkedIn authentication...");
+            console.log(`\nIf the browser doesn't open, visit this URL:\n${authUrl}\n`);
+            if (openUrlFn) {
+                await openUrlFn(authUrl);
+            }
+            else {
+                (0, child_process_1.execFile)("open", [authUrl]);
+            }
+            console.log("Waiting for callback on localhost:3000...");
+        });
+        server.on("error", (err) => {
+            reject(new Error(`Failed to start callback server: ${err.message}`));
+        });
+    });
+    console.log("Authorization code received.");
+    // 2. Exchange code for tokens
+    console.log("Exchanging code for tokens...");
+    const tokenResp = await httpsPost("https://www.linkedin.com/oauth/v2/accessToken", new URLSearchParams({
+        grant_type: "authorization_code",
+        code: authCode,
+        client_id: clientId,
+        client_secret: clientSecret,
+        redirect_uri: REDIRECT_URI,
+    }).toString(), { "Content-Type": "application/x-www-form-urlencoded" });
+    const tokens = JSON.parse(tokenResp.body);
+    if (!tokens.access_token) {
+        throw new Error(`Token exchange failed: ${tokenResp.body}`);
+    }
+    console.log("Access token obtained.");
+    // 3. Get person ID
+    console.log("Fetching person ID...");
+    const userResp = await httpsGet("https://api.linkedin.com/v2/userinfo", {
+        Authorization: `Bearer ${tokens.access_token}`,
+    });
+    const userInfo = JSON.parse(userResp.body);
+    const personId = userInfo.sub || "";
+    if (!personId) {
+        throw new Error("Could not retrieve person ID from userinfo.");
+    }
+    console.log(`Person ID: ${personId}`);
+    // 4. Save credentials
+    const expiresAt = Math.floor(Date.now() / 1000) + (tokens.expires_in || 5184000);
+    const credentials = {
+        clientId,
+        clientSecret,
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token || "",
+        personId,
+        expiresAt,
+    };
+    saveCredentials(credentials);
+    return credentials;
+}
+async function refreshAccessToken(creds) {
+    if (!creds.refreshToken) {
+        throw new Error("No refresh token available. Run 'linkedin-agent auth' again.");
+    }
+    console.log("Refreshing access token...");
+    const resp = await httpsPost("https://www.linkedin.com/oauth/v2/accessToken", new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: creds.refreshToken,
+        client_id: creds.clientId,
+        client_secret: creds.clientSecret,
+    }).toString(), { "Content-Type": "application/x-www-form-urlencoded" });
+    const tokens = JSON.parse(resp.body);
+    if (!tokens.access_token) {
+        throw new Error(`Token refresh failed: ${resp.body}`);
+    }
+    const updated = {
+        ...creds,
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token || creds.refreshToken,
+        expiresAt: Math.floor(Date.now() / 1000) + (tokens.expires_in || 5184000),
+    };
+    saveCredentials(updated);
+    console.log("Token refreshed successfully.");
+    return updated;
+}
+async function getValidCredentials() {
+    const creds = loadCredentials();
+    if (!creds) {
+        throw new Error("No credentials found. Run 'linkedin-agent auth' first.");
+    }
+    // Refresh if expiring within 1 day
+    const oneDayFromNow = Math.floor(Date.now() / 1000) + 86400;
+    if (creds.expiresAt < oneDayFromNow) {
+        return refreshAccessToken(creds);
+    }
+    return creds;
+}

package/dist/browser.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserDataDir = getUserDataDir;
+exports.launchBrowser = launchBrowser;
+exports.ensureLoggedIn = ensureLoggedIn;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const playwright_1 = require("playwright");
+const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+function getUserDataDir() {
+    const dir = path.join(os.homedir(), ".linkedin-agent", "chrome-data");
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+async function launchBrowser(userDataDir) {
+    return playwright_1.chromium.launchPersistentContext(userDataDir || getUserDataDir(), {
+        headless: false,
+        args: ["--disable-blink-features=AutomationControlled"],
+        viewport: { width: 1280, height: 900 },
+        userAgent: USER_AGENT,
+    });
+}
+async function ensureLoggedIn(page) {
+    await page.goto("https://www.linkedin.com/feed/", { waitUntil: "domcontentloaded" });
+    await page.waitForLoadState("networkidle").catch(() => { });
+    await page.waitForTimeout(1500);
+    const url = page.url();
+    if (url.includes("/login") || url.includes("/authwall") || url.includes("/checkpoint")) {
+        console.log("🔐 Login required. Please log in via the browser...");
+        await page.waitForFunction(() => {
+            const u = window.location.href;
+            return !u.includes("/login") && !u.includes("/authwall") && !u.includes("/checkpoint");
+        }, undefined, { timeout: 300_000 });
+        await page.waitForLoadState("networkidle").catch(() => { });
+        await page.waitForTimeout(1500);
+    }
+    console.log("✅ Session active.\n");
+}