linkedin-automation-cli 1.0.0

package/src/core/audit.ts

@@ -0,0 +1,98 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface AuditEntry {
+  timestamp: string;
+  action: string;
+  details: Record<string, unknown>;
+  success: boolean;
+}
+
+export class AuditLogger {
+  private logPath: string;
+  private consoleEnabled: boolean;
+
+  constructor() {
+    const dataDir = path.join(os.homedir(), '.linkedin-cli');
+    this.logPath = path.join(dataDir, 'audit.log');
+    this.consoleEnabled = process.env.DEBUG === 'true';
+    this.ensureLogDirectory();
+  }
+
+  private ensureLogDirectory(): void {
+    const dir = path.dirname(this.logPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  log(action: string, details: Record<string, unknown> = {}, success: boolean = true): void {
+    const entry: AuditEntry = {
+      timestamp: new Date().toISOString(),
+      action,
+      details,
+      success,
+    };
+
+    try {
+      const logLine = JSON.stringify(entry) + '\n';
+      fs.appendFileSync(this.logPath, logLine);
+    } catch (error) {
+      console.warn('Failed to write audit log:', error);
+    }
+
+    if (this.consoleEnabled) {
+      const status = success ? 'OK' : 'FAIL';
+      console.log('[AUDIT] ' + status + ' ' + action, details);
+    }
+  }
+
+  readRecent(count: number = 100): AuditEntry[] {
+    try {
+      if (!fs.existsSync(this.logPath)) {
+        return [];
+      }
+
+      const content = fs.readFileSync(this.logPath, 'utf-8');
+      const lines = content
+        .trim()
+        .split('\n')
+        .filter((line) => line.length > 0);
+
+      const entries: AuditEntry[] = [];
+      for (let i = Math.max(0, lines.length - count); i < lines.length; i++) {
+        try {
+          const entry = JSON.parse(lines[i]) as AuditEntry;
+          entries.push(entry);
+        } catch {
+          // Skip invalid lines
+        }
+      }
+
+      return entries;
+    } catch (error) {
+      console.error('Failed to read audit log:', error);
+      return [];
+    }
+  }
+
+  clear(): void {
+    try {
+      if (fs.existsSync(this.logPath)) {
+        fs.writeFileSync(this.logPath, '');
+      }
+    } catch (error) {
+      console.error('Failed to clear audit log:', error);
+    }
+  }
+}
+
+let auditLogger: AuditLogger | null = null;
+
+export function getAuditLogger(): AuditLogger {
+  if (!auditLogger) {
+    auditLogger = new AuditLogger();
+  }
+  return auditLogger;
+}

package/src/core/browser-cookies.ts

@@ -0,0 +1,203 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import initSqlJs, { Database } from 'sql.js';
+
+export interface BrowserCookie {
+  name: string;
+  value: string;
+  domain: string;
+  path: string;
+  expires?: number;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: 'Strict' | 'Lax' | 'None';
+}
+
+interface BrowserProfile {
+  name: string;
+  cookiePath: string;
+}
+
+const BROWSER_PROFILES: Record<string, BrowserProfile[]> = {
+  chrome: [
+    {
+      name: 'Chrome Default',
+      cookiePath: path.join(
+        os.homedir(),
+        'Library/Application Support/Google/Chrome/Default/Cookies'
+      ),
+    },
+    {
+      name: 'Chrome Profile 1',
+      cookiePath: path.join(
+        os.homedir(),
+        'Library/Application Support/Google/Chrome/Profile 1/Cookies'
+      ),
+    },
+  ],
+  edge: [
+    {
+      name: 'Edge Default',
+      cookiePath: path.join(
+        os.homedir(),
+        'Library/Application Support/Microsoft Edge/Default/Cookies'
+      ),
+    },
+    {
+      name: 'Edge Profile 1',
+      cookiePath: path.join(
+        os.homedir(),
+        'Library/Application Support/Microsoft Edge/Profile 1/Cookies'
+      ),
+    },
+  ],
+  arc: [
+    {
+      name: 'Arc Default',
+      cookiePath: path.join(
+        os.homedir(),
+        'Library/Application Support/Arc/User Data/Default/Cookies'
+      ),
+    },
+  ],
+  brave: [
+    {
+      name: 'Brave Default',
+      cookiePath: path.join(
+        os.homedir(),
+        'Library/Application Support/BraveSoftware/Brave-Browser/Default/Cookies'
+      ),
+    },
+  ],
+};
+
+/**
+ * Copy cookie database to temp location (Chrome locks the original)
+ */
+function copyCookieDatabase(sourcePath: string): string {
+  const tempPath = path.join(os.tmpdir(), `linkedin-cli-cookies-${Date.now()}.db`);
+
+  // Copy the file
+  fs.copyFileSync(sourcePath, tempPath);
+
+  return tempPath;
+}
+
+/**
+ * Extract LinkedIn cookies from browser's cookie database
+ */
+export async function extractCookiesFromBrowser(browserName: string): Promise<BrowserCookie[]> {
+  const profiles = BROWSER_PROFILES[browserName.toLowerCase()];
+  if (!profiles) {
+    throw new Error(
+      `Unsupported browser: ${browserName}. Supported: ${Object.keys(BROWSER_PROFILES).join(', ')}`
+    );
+  }
+
+  // Find existing cookie database
+  let cookiePath: string | null = null;
+  let profileName: string | null = null;
+
+  for (const profile of profiles) {
+    if (fs.existsSync(profile.cookiePath)) {
+      cookiePath = profile.cookiePath;
+      profileName = profile.name;
+      break;
+    }
+  }
+
+  if (!cookiePath) {
+    throw new Error(
+      `Cookie database not found for ${browserName}. Make sure the browser is installed and you're logged into LinkedIn.`
+    );
+  }
+
+  console.log(`Found ${browserName} profile: ${profileName}`);
+
+  // Copy to temp location (original is locked by browser)
+  const tempPath = copyCookieDatabase(cookiePath);
+
+  try {
+    // Initialize sql.js
+    const SQL = await initSqlJs();
+
+    // Open the copied database
+    const fileBuffer = fs.readFileSync(tempPath);
+    const db: Database = new SQL.Database(fileBuffer);
+
+    // Check schema - older Chrome versions don't have same_site
+    const tableInfo = db.exec('PRAGMA table_info(cookies)');
+    const hasSameSite =
+      tableInfo.length > 0 && tableInfo[0].values.some((row: any[]) => row[1] === 'same_site');
+
+    // Query LinkedIn cookies (adapt to schema)
+    const query = hasSameSite
+      ? `SELECT name, value, host_key, path, expires_utc, is_secure, is_httponly, same_site FROM cookies WHERE host_key LIKE '%linkedin.com%'`
+      : `SELECT name, value, host_key, path, expires_utc, is_secure, is_httponly FROM cookies WHERE host_key LIKE '%linkedin.com%'`;
+
+    const rows = db.exec(query);
+
+    db.close();
+
+    if (rows.length === 0 || rows[0].values.length === 0) {
+      db.close();
+      return [];
+    }
+
+    const columns = rows[0].columns;
+    const values = rows[0].values;
+
+    return values.map((row: any[]) => {
+      const data: any = {};
+      columns.forEach((col: string, i: number) => {
+        data[col] = row[i];
+      });
+
+      return {
+        name: data.name as string,
+        value: data.value as string,
+        domain: (data.host_key as string).startsWith('.') ? data.host_key : `.${data.host_key}`,
+        path: data.path as string,
+        expires:
+          (data.expires_utc as number) > 0
+            ? Math.floor((data.expires_utc as number) / 1000000 - 11644473600)
+            : undefined,
+        httpOnly: (data.is_httponly as number) === 1,
+        secure: (data.is_secure as number) === 1,
+        sameSite:
+          data.same_site !== undefined
+            ? sameSiteFromValue(data.same_site as number)
+            : ('Lax' as const),
+      } as BrowserCookie;
+    });
+  } finally {
+    // Clean up temp file
+    if (fs.existsSync(tempPath)) {
+      fs.unlinkSync(tempPath);
+    }
+  }
+}
+
+function sameSiteFromValue(value: number): 'Strict' | 'Lax' | 'None' {
+  switch (value) {
+    case 1:
+      return 'Lax';
+    case 2:
+      return 'Strict';
+    case 3:
+      return 'None';
+    default:
+      return 'Lax';
+  }
+}
+
+/**
+ * Extract LinkedIn cookies and return as Playwright-compatible format
+ */
+export async function getLinkedinCookies(browserName: string): Promise<BrowserCookie[]> {
+  const cookies = await extractCookiesFromBrowser(browserName);
+
+  // Get all LinkedIn cookies - we need more than just auth cookies
+  return cookies.filter(() => true);
+}

package/src/core/browser.ts

@@ -0,0 +1,304 @@
+import { chromium, Browser, BrowserContext, Page, type LaunchOptions } from 'playwright';
+import ora from 'ora';
+import { getConfig } from './config';
+import type { Session } from '../types';
+
+export interface BrowserOptions {
+  headless?: boolean;
+  slowMo?: number;
+  viewport?: { width: number; height: number };
+  debug?: boolean;
+}
+
+export class BrowserController {
+  private browser: Browser | null = null;
+  private context: BrowserContext | null = null;
+  private page: Page | null = null;
+  private options: BrowserOptions;
+  private debugDir: string;
+  private isUsingExistingBrowser: boolean = false;
+
+  constructor(options: BrowserOptions = {}) {
+    const config = getConfig().get();
+    this.options = {
+      headless: options.headless ?? config.headless,
+      slowMo: options.slowMo ?? 100,
+      viewport: options.viewport ?? { width: 1280, height: 720 },
+      debug: options.debug ?? false,
+    };
+    this.debugDir = `${process.env.HOME || process.env.USERPROFILE || '.'}/.linkedin-cli/debug`;
+  }
+
+  async launch(): Promise<Page> {
+    const spinner = ora('Launching browser...').start();
+
+    try {
+      // Try to connect to existing Chrome/Edge via CDP first
+      const cdpBrowser = await this.connectToExistingBrowser();
+      if (cdpBrowser) {
+        spinner.succeed('Connected to existing browser');
+        return this.page!;
+      }
+
+      // Fall back to launching Chromium
+      const launchOptions: LaunchOptions = {
+        headless: this.options.headless,
+        slowMo: this.options.slowMo,
+        args: [
+          '--disable-blink-features=AutomationControlled',
+          '--disable-web-security',
+          '--disable-features=IsolateOrigins,site-per-process',
+        ],
+      };
+
+      this.browser = await chromium.launch(launchOptions);
+
+      this.context = await this.browser.newContext({
+        viewport: this.options.viewport,
+        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',
+        extraHTTPHeaders: {
+          'Accept-Language': 'en-US,en;q=0.9',
+        },
+      });
+
+      // Add stealth script to hide Playwright detection
+      await this.context.addInitScript(`
+        Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+        window.chrome = { runtime: {} };
+        const originalQuery = window.navigator.permissions.query;
+        window.navigator.permissions.query = (parameters) =>
+          parameters.name === 'notifications'
+            ? Promise.resolve({ state: Notification.permission })
+            : originalQuery(parameters);
+      `);
+
+      this.page = await this.context.newPage();
+      spinner.succeed('Browser launched');
+      return this.page;
+    } catch (error) {
+      spinner.fail('Failed to launch browser');
+      throw error;
+    }
+  }
+
+  async restoreSession(session: Session): Promise<boolean> {
+    if (!this.context) throw new Error('Browser not launched');
+    try {
+      if (session.cookies?.length > 0) {
+        await this.context.addCookies(session.cookies);
+      }
+      await this.page?.evaluate((data) => {
+        Object.entries(data).forEach(([key, value]) =>
+          window.localStorage.setItem(key, value as string)
+        );
+      }, session.localStorage || {});
+      return true;
+    } catch (error) {
+      console.error('Failed to restore session:', error);
+      return false;
+    }
+  }
+
+  async saveSession(): Promise<Session | null> {
+    if (!this.context || !this.page) return null;
+    try {
+      const cookies = await this.context.cookies();
+      const localStorage = await this.page.evaluate(() => {
+        const data: Record<string, string> = {};
+        const storage = window.localStorage;
+        for (let i = 0; i < storage.length; i++) {
+          const key = storage.key(i);
+          if (key) data[key] = storage.getItem(key) || '';
+        }
+        return data;
+      });
+      return { cookies, localStorage, timestamp: new Date() };
+    } catch (error) {
+      console.error('Failed to save session:', error);
+      return null;
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.browser) {
+      if (this.isUsingExistingBrowser) {
+        // Don't close the browser - just disconnect from CDP
+        // The user's browser stays open with all cookies intact
+        console.log('Disconnecting from existing browser (keeping your session)');
+        this.browser = null;
+        this.context = null;
+        this.page = null;
+      } else {
+        // Close the browser we launched
+        await this.browser.close();
+        this.browser = null;
+        this.context = null;
+        this.page = null;
+      }
+    }
+  }
+
+  getPage(): Page | null {
+    return this.page;
+  }
+  isLaunched(): boolean {
+    return this.browser !== null && this.page !== null;
+  }
+  private async ensureDebugDir(): Promise<void> {
+    const fs = await import('fs/promises');
+    await fs.mkdir(this.debugDir, { recursive: true });
+  }
+
+  async takeScreenshot(stepName: string): Promise<void> {
+    if (!this.options.debug || !this.page) return;
+
+    try {
+      await this.ensureDebugDir();
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+      const filename = `${this.debugDir}/${timestamp}-${stepName}.png`;
+      await this.page.screenshot({ path: filename, fullPage: true });
+      console.log(`[DEBUG] Screenshot saved: ${filename}`);
+    } catch (error) {
+      console.error('[DEBUG] Failed to save screenshot:', error);
+    }
+  }
+
+  async saveHtmlSnapshot(stepName: string): Promise<void> {
+    if (!this.options.debug || !this.page) return;
+
+    try {
+      await this.ensureDebugDir();
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+      const filename = `${this.debugDir}/${timestamp}-${stepName}.html`;
+      const html = await this.page.content();
+      const fs = await import('fs/promises');
+      await fs.writeFile(filename, html, 'utf-8');
+      console.log(`[DEBUG] HTML snapshot saved: ${filename}`);
+    } catch (error) {
+      console.error('[DEBUG] Failed to save HTML snapshot:', error);
+    }
+  }
+
+  debugLog(message: string): void {
+    if (this.options.debug) {
+      console.log(`[DEBUG] ${message}`);
+    }
+  }
+
+  /**
+   * Try to connect to an existing Chrome/Edge browser via CDP
+   * Returns true if connected to existing browser with LinkedIn session
+   */
+  private async connectToExistingBrowser(): Promise<boolean> {
+    try {
+      // Try common CDP ports for Chrome and Edge
+      const ports = [9222, 9223, 9224, 9225];
+
+      for (const port of ports) {
+        try {
+          const response = await fetch(`http://localhost:${port}/json/version`);
+          if (response.ok) {
+            const data = await response.json();
+            console.log(`Found browser at port ${port}: ${data.Browser}`);
+
+            // Connect via CDP
+            this.browser = await chromium.connectOverCDP(`http://localhost:${port}`);
+
+            // Get the default context (first one is the user's actual browser session)
+            const contexts = this.browser.contexts();
+            this.context = contexts.length > 0 ? contexts[0] : await this.browser.newContext();
+
+            // Wait a moment for pages to be available
+            await new Promise((resolve) => setTimeout(resolve, 500));
+
+            // Find a page/tab that's already on LinkedIn
+            const pages = this.context.pages();
+            console.log(`Found ${pages.length} pages in browser context`);
+
+            if (pages.length > 0) {
+              // Check if any tab is on LinkedIn - use the first LinkedIn tab we find
+              // Support both linkedin.com and linkedin.cn (China's LinkedIn)
+              for (const pg of pages) {
+                try {
+                  const url = pg.url();
+                  console.log(`  Page URL: ${url}`);
+                  if (url.includes('linkedin.com') || url.includes('linkedin.cn')) {
+                    console.log(`Found LinkedIn tab: ${url}`);
+                    this.page = pg;
+                    this.isUsingExistingBrowser = true;
+                    return true; // Connected to existing LinkedIn session
+                  }
+                } catch (e) {
+                  // Skip pages that can't be accessed
+                  console.log(`  Page access error: ${e}`);
+                  continue;
+                }
+              }
+            }
+
+            // No LinkedIn tab found, create a new tab in the existing context
+            console.log('Creating new tab in existing browser session...');
+            this.page = await this.context.newPage();
+            this.isUsingExistingBrowser = true;
+
+            return true; // Connected to browser (but may need to navigate to LinkedIn)
+          }
+        } catch {
+          // Port not available, try next
+          continue;
+        }
+      }
+    } catch (error) {
+      console.log('Could not connect to browser via CDP:', error);
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if connected to existing browser via CDP
+   */
+  isUsingCDP(): boolean {
+    return this.browser !== null && this.page !== null && this.context !== null;
+  }
+
+  /**
+   * Check if the current page is on linkedin.cn (which has limited functionality)
+   * Returns true if on linkedin.cn, false if on linkedin.com or not on LinkedIn
+   */
+  isOnLinkedInCN(): boolean {
+    if (!this.page) return false;
+    try {
+      const currentUrl = this.page.url();
+      return currentUrl.includes('linkedin.cn');
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Navigate to LinkedIn in the current page
+   */
+  async ensureLinkedIn(): Promise<void> {
+    if (!this.page) throw new Error('Browser not launched');
+
+    const currentUrl = this.page.url();
+    if (currentUrl.includes('linkedin.com') || currentUrl.includes('linkedin.cn')) {
+      console.log('Already on LinkedIn:', currentUrl);
+      return;
+    }
+
+    console.log('Navigating to LinkedIn...');
+    await this.page.goto('https://www.linkedin.com/feed', {
+      waitUntil: 'domcontentloaded',
+      timeout: 30000,
+    });
+  }
+}
+
+export async function createBrowser(options?: BrowserOptions): Promise<BrowserController> {
+  const controller = new BrowserController(options);
+  await controller.launch();
+  return controller;
+}

package/src/core/config.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+import { ConfigManager, getConfig } from './config';
+
+describe('ConfigManager', () => {
+  let configManager: ConfigManager;
+  const configPath = path.join(os.homedir(), '.linkedin-cli', 'config.json');
+
+  beforeEach(() => {
+    // Clean up before test
+    if (fs.existsSync(configPath)) {
+      fs.rmSync(configPath, { force: true });
+    }
+    configManager = new ConfigManager();
+  });
+
+  afterEach(() => {
+    // Clean up after test
+    if (fs.existsSync(configPath)) {
+      fs.rmSync(configPath, { force: true });
+    }
+  });
+
+  describe('initialization', () => {
+    it('should load with default values', () => {
+      const config = configManager.get();
+      expect(config.headless).toBe(true);
+      expect(config.rateLimit).toBe(5000);
+      expect(config.sessionTimeout).toBe(86400000);
+      expect(config.dryRun).toBe(false);
+      expect(config.dataDir).toContain('.linkedin-cli');
+    });
+  });
+
+  describe('get', () => {
+    it('should return a copy of config', () => {
+      const config1 = configManager.get();
+      const config2 = configManager.get();
+
+      // Should be equal but not the same reference
+      expect(config1).toEqual(config2);
+      expect(config1).not.toBe(config2);
+    });
+  });
+
+  describe('getValue', () => {
+    it('should return specific config value', () => {
+      expect(configManager.getValue('headless')).toBe(true);
+      expect(configManager.getValue('rateLimit')).toBe(5000);
+    });
+  });
+
+  describe('set', () => {
+    it('should set a single config value', () => {
+      configManager.set('headless', false);
+      expect(configManager.getValue('headless')).toBe(false);
+    });
+
+    it('should persist to file', () => {
+      configManager.set('headless', false);
+
+      // Create new instance to verify persistence
+      const newManager = new ConfigManager();
+      expect(newManager.getValue('headless')).toBe(false);
+    });
+  });
+
+  describe('reset', () => {
+    it('should reset to default values', () => {
+      configManager.set('headless', false);
+      configManager.set('rateLimit', 10000);
+
+      configManager.reset();
+
+      expect(configManager.getValue('headless')).toBe(true);
+      expect(configManager.getValue('rateLimit')).toBe(5000);
+    });
+  });
+});
+
+describe('getConfig singleton', () => {
+  it('should return same instance on multiple calls', () => {
+    const config1 = getConfig();
+    const config2 = getConfig();
+    expect(config1).toBe(config2);
+  });
+});