linkedin-automation-cli 1.0.0

package/src/templates/defaults/welcome.txt

@@ -0,0 +1,14 @@
+---
+name: Welcome Message
+description: Initial outreach message to new connections
+category: welcome
+---
+
+Hi {{firstName}},
+
+Thanks for connecting! I noticed you're working at {{company}} - that's really interesting work.
+
+I'd love to learn more about what you're currently focused on. Are you open to a brief chat sometime this week?
+
+Best regards,
+{{senderName}}

package/src/templates/engine.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// Mock the paths module
+vi.mock('../utils/paths', () => {
+  const testDir = path.join(os.tmpdir(), 'linkedin-cli-templates-test');
+  return {
+    getConfigDir: () => testDir,
+    getSessionsDir: () => path.join(testDir, 'sessions'),
+    getTemplatesDir: () => path.join(testDir, 'templates'),
+    getDefaultsDir: () => path.join(testDir, 'templates', 'defaults'),
+    getCustomDir: () => path.join(testDir, 'templates', 'custom'),
+    getConfigFile: () => path.join(testDir, 'config.json'),
+    getLogFile: () => path.join(testDir, 'audit.log'),
+  };
+});
+
+import { TemplateEngine, getTemplateEngine } from './engine';
+
+describe('TemplateEngine', () => {
+  let engine: TemplateEngine;
+  const testDir = path.join(os.tmpdir(), 'linkedin-cli-templates-test');
+  const defaultsDir = path.join(testDir, 'templates', 'defaults');
+  const customDir = path.join(testDir, 'templates', 'custom');
+
+  beforeEach(() => {
+    // Clean up test directory
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+    engine = new TemplateEngine();
+  });
+
+  afterEach(() => {
+    // Clean up after tests
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('load', () => {
+    it('should return null for non-existent template', () => {
+      const template = engine.load('non-existent');
+      expect(template).toBeNull();
+    });
+
+    it('should load template from defaults', () => {
+      // Create a default template
+      fs.mkdirSync(defaultsDir, { recursive: true });
+      fs.writeFileSync(path.join(defaultsDir, 'test.txt'), 'Hello {{name}}!');
+
+      const template = engine.load('test');
+
+      expect(template).toBeTruthy();
+      expect(template?.id).toBe('test');
+      expect(template?.content).toBe('Hello {{name}}!');
+    });
+
+    it('should prefer custom templates over defaults', () => {
+      // Create both default and custom templates
+      fs.mkdirSync(defaultsDir, { recursive: true });
+      fs.mkdirSync(customDir, { recursive: true });
+
+      fs.writeFileSync(path.join(defaultsDir, 'test.txt'), 'Default content');
+      fs.writeFileSync(path.join(customDir, 'test.txt'), 'Custom content');
+
+      const template = engine.load('test');
+
+      expect(template?.content).toBe('Custom content');
+    });
+  });
+
+  describe('parseTemplate', () => {
+    it('should parse template without frontmatter', () => {
+      fs.mkdirSync(defaultsDir, { recursive: true });
+      fs.writeFileSync(path.join(defaultsDir, 'simple.txt'), 'Hello {{firstName}}!');
+
+      const template = engine.load('simple');
+
+      expect(template?.name).toBe('simple');
+      expect(template?.content).toBe('Hello {{firstName}}!');
+      expect(template?.variables).toContain('firstName');
+    });
+
+    it('should parse template with frontmatter', () => {
+      fs.mkdirSync(defaultsDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(defaultsDir, 'frontmatter.txt'),
+        `---
+name: Welcome Template
+description: A welcome message
+category: welcome
+---
+
+Hi {{firstName}}, welcome to {{company}}!`
+      );
+
+      const template = engine.load('frontmatter');
+
+      expect(template?.name).toBe('Welcome Template');
+      expect(template?.description).toBe('A welcome message');
+      expect(template?.category).toBe('welcome');
+      expect(template?.variables).toEqual(['firstName', 'company']);
+    });
+
+    it('should extract unique variables', () => {
+      fs.mkdirSync(defaultsDir, { recursive: true });
+      fs.writeFileSync(path.join(defaultsDir, 'multi-var.txt'), '{{name}} {{name}} {{other}}');
+
+      const template = engine.load('multi-var');
+
+      expect(template?.variables).toEqual(['name', 'other']);
+    });
+  });
+
+  describe('save', () => {
+    it('should save custom template', () => {
+      const template = {
+        id: 'custom-test',
+        name: 'Custom Test',
+        description: 'Test template',
+        content: 'Hello {{name}}!',
+        variables: ['name'],
+        category: 'custom' as const,
+      };
+
+      engine.save(template);
+
+      const loaded = engine.load('custom-test');
+      expect(loaded?.name).toBe('Custom Test');
+      expect(loaded?.content).toBe('Hello {{name}}!');
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete custom template', () => {
+      fs.mkdirSync(customDir, { recursive: true });
+      fs.writeFileSync(path.join(customDir, 'to-delete.txt'), 'Content to delete');
+
+      const deleted = engine.delete('to-delete');
+
+      expect(deleted).toBe(true);
+      expect(engine.load('to-delete')).toBeNull();
+    });
+
+    it('should return false for non-existent template', () => {
+      const deleted = engine.delete('non-existent');
+      expect(deleted).toBe(false);
+    });
+
+    it('should not delete default templates', () => {
+      fs.mkdirSync(defaultsDir, { recursive: true });
+      fs.writeFileSync(path.join(defaultsDir, 'default.txt'), 'Default content');
+
+      const deleted = engine.delete('default');
+
+      expect(deleted).toBe(false);
+      expect(engine.load('default')).toBeTruthy();
+    });
+  });
+
+  describe('list', () => {
+    it('should return empty array when no templates exist', () => {
+      const templates = engine.list();
+      expect(templates).toEqual([]);
+    });
+
+    it('should list all templates', () => {
+      fs.mkdirSync(defaultsDir, { recursive: true });
+      fs.writeFileSync(path.join(defaultsDir, 'template1.txt'), 'Content 1');
+      fs.writeFileSync(path.join(defaultsDir, 'template2.txt'), 'Content 2');
+
+      const templates = engine.list();
+
+      expect(templates.length).toBe(2);
+      expect(templates.map((t) => t.id)).toEqual(
+        expect.arrayContaining(['template1', 'template2'])
+      );
+    });
+  });
+
+  describe('render', () => {
+    it('should render template with variables', () => {
+      fs.mkdirSync(defaultsDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(defaultsDir, 'render-test.txt'),
+        'Hello {{firstName}} {{lastName}}!'
+      );
+
+      const result = engine.render('render-test', {
+        variables: {
+          firstName: 'John',
+          lastName: 'Doe',
+        },
+      });
+
+      expect(result).toBe('Hello John Doe!');
+    });
+
+    it('should use fallback for missing variables', () => {
+      fs.mkdirSync(defaultsDir, { recursive: true });
+      fs.writeFileSync(path.join(defaultsDir, 'fallback-test.txt'), 'Hello {{firstName}}!');
+
+      const result = engine.render('fallback-test', {
+        variables: {},
+        fallback: '[NAME]',
+      });
+
+      expect(result).toBe('Hello [NAME]!');
+    });
+
+    it('should throw for non-existent template', () => {
+      expect(() => {
+        engine.render('non-existent', { variables: {} });
+      }).toThrow('Template "non-existent" not found');
+    });
+  });
+});
+
+describe('getTemplateEngine singleton', () => {
+  it('should return same instance on multiple calls', () => {
+    const engine1 = getTemplateEngine();
+    const engine2 = getTemplateEngine();
+    expect(engine1).toBe(engine2);
+  });
+});

package/src/templates/engine.ts

@@ -0,0 +1,208 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getDefaultsDir, getCustomDir } from '../utils/paths';
+import type { Template } from '../types';
+
+export interface RenderOptions {
+  variables: Record<string, string>;
+  fallback?: string;
+}
+
+export class TemplateEngine {
+  private defaultsDir: string;
+  private customDir: string;
+
+  constructor() {
+    this.defaultsDir = getDefaultsDir();
+    this.customDir = getCustomDir();
+    this.ensureDirectories();
+  }
+
+  private ensureDirectories(): void {
+    if (!fs.existsSync(this.defaultsDir)) {
+      fs.mkdirSync(this.defaultsDir, { recursive: true });
+    }
+    if (!fs.existsSync(this.customDir)) {
+      fs.mkdirSync(this.customDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Load a template by ID
+   */
+  load(templateId: string): Template | null {
+    // Try custom templates first (user overrides)
+    const customPath = path.join(this.customDir, `${templateId}.txt`);
+    if (fs.existsSync(customPath)) {
+      return this.parseTemplate(templateId, customPath);
+    }
+
+    // Fall back to defaults
+    const defaultPath = path.join(this.defaultsDir, `${templateId}.txt`);
+    if (fs.existsSync(defaultPath)) {
+      return this.parseTemplate(templateId, defaultPath);
+    }
+
+    return null;
+  }
+
+  /**
+   * Parse a template file into a Template object
+   */
+  private parseTemplate(id: string, filePath: string): Template {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    // Parse frontmatter if present
+    let name = id;
+    let description = '';
+    let category: Template['category'] = 'custom';
+    let variables: string[] = [];
+    let templateContent = content;
+
+    if (lines[0] === '---') {
+      const endIndex = lines.indexOf('---', 1);
+      if (endIndex !== -1) {
+        const frontmatter = lines.slice(1, endIndex).join('\n');
+        templateContent = lines.slice(endIndex + 1).join('\n');
+
+        // Parse YAML-like frontmatter
+        for (const line of frontmatter.split('\n')) {
+          const match = line.match(/^(\w+):\s*(.+)$/);
+          if (match) {
+            const [, key, value] = match;
+            switch (key) {
+              case 'name':
+                name = value;
+                break;
+              case 'description':
+                description = value;
+                break;
+              case 'category':
+                if (['welcome', 'followup', 'meeting', 'custom'].includes(value)) {
+                  category = value as Template['category'];
+                }
+                break;
+            }
+          }
+        }
+      }
+    }
+
+    // Extract variables from template content
+    const variableMatches = templateContent.match(/\{\{(\w+)\}\}/g);
+    if (variableMatches) {
+      variables = [...new Set(variableMatches.map((m) => m.replace(/[\{\}]/g, '')))];
+    }
+
+    return {
+      id,
+      name,
+      description,
+      content: templateContent.trim(),
+      variables,
+      category,
+    };
+  }
+
+  /**
+   * Save a custom template
+   */
+  save(template: Template): void {
+    const filePath = path.join(this.customDir, `${template.id}.txt`);
+
+    const frontmatter = [
+      '---',
+      `name: ${template.name}`,
+      `description: ${template.description}`,
+      `category: ${template.category}`,
+      '---',
+    ].join('\n');
+
+    const content = `${frontmatter}\n\n${template.content}`;
+    fs.writeFileSync(filePath, content);
+  }
+
+  /**
+   * Delete a custom template
+   */
+  delete(templateId: string): boolean {
+    const customPath = path.join(this.customDir, `${templateId}.txt`);
+    if (fs.existsSync(customPath)) {
+      fs.unlinkSync(customPath);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * List all available templates
+   */
+  list(): Template[] {
+    const templates: Template[] = [];
+
+    // Load defaults
+    if (fs.existsSync(this.defaultsDir)) {
+      const defaultFiles = fs.readdirSync(this.defaultsDir).filter((f) => f.endsWith('.txt'));
+      for (const file of defaultFiles) {
+        const id = path.basename(file, '.txt');
+        const template = this.load(id);
+        if (template) templates.push(template);
+      }
+    }
+
+    // Load customs (may override defaults)
+    if (fs.existsSync(this.customDir)) {
+      const customFiles = fs.readdirSync(this.customDir).filter((f) => f.endsWith('.txt'));
+      for (const file of customFiles) {
+        const id = path.basename(file, '.txt');
+        const template = this.load(id);
+        if (template) {
+          // Remove default if exists
+          const existingIndex = templates.findIndex((t) => t.id === id);
+          if (existingIndex !== -1) {
+            templates.splice(existingIndex, 1);
+          }
+          templates.push(template);
+        }
+      }
+    }
+
+    return templates;
+  }
+
+  /**
+   * Render a template with variables
+   */
+  render(templateId: string, options: RenderOptions): string {
+    const template = this.load(templateId);
+    if (!template) {
+      throw new Error(`Template "${templateId}" not found`);
+    }
+
+    let content = template.content;
+
+    // Replace variables
+    for (const [key, value] of Object.entries(options.variables)) {
+      const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, 'g');
+      content = content.replace(regex, value);
+    }
+
+    // Handle missing variables
+    if (options.fallback !== undefined) {
+      content = content.replace(/\{\{\s*\w+\s*\}\}/g, options.fallback);
+    }
+
+    return content;
+  }
+}
+
+// Singleton instance
+let templateEngine: TemplateEngine | null = null;
+
+export function getTemplateEngine(): TemplateEngine {
+  if (!templateEngine) {
+    templateEngine = new TemplateEngine();
+  }
+  return templateEngine;
+}

package/src/templates/index.ts

@@ -0,0 +1 @@
+export { TemplateEngine, getTemplateEngine, type RenderOptions } from './engine';

package/src/types/index.test.ts

@@ -0,0 +1,94 @@
+// src/types/index.test.ts
+import { describe, it, expect } from 'vitest';
+import type { ProfileData, ProfileExtractionOptions, ProfileExtractionResult } from '../types';
+
+describe('Profile Types', () => {
+  describe('ProfileData', () => {
+    it('should allow valid ProfileData', () => {
+      const data: ProfileData = {
+        full_name: 'John Doe',
+        headline: 'Engineer at Company',
+        location: 'San Francisco',
+        current_company: 'Company',
+        current_title: 'Engineer',
+        company_linkedin_url: 'https://linkedin.com/company/x',
+        years_experience: 5,
+        email: 'john@example.com',
+        phone: '+1234567890',
+        profile_url: 'https://www.linkedin.com/in/johndoe',
+      };
+      expect(data.full_name).toBe('John Doe');
+    });
+
+    it('should allow null optional fields', () => {
+      const data: ProfileData = {
+        full_name: 'Jane Doe',
+        headline: '',
+        location: '',
+        current_company: null,
+        current_title: null,
+        company_linkedin_url: null,
+        years_experience: null,
+        email: null,
+        phone: null,
+        profile_url: 'https://www.linkedin.com/in/janedoe',
+      };
+      expect(data.current_company).toBeNull();
+    });
+  });
+
+  describe('ProfileExtractionOptions', () => {
+    it('should allow valid options with all fields', () => {
+      const options: ProfileExtractionOptions = {
+        profileUrl: 'https://www.linkedin.com/in/johndoe/',
+        includeContact: true,
+        timeout: 30000,
+      };
+      expect(options.profileUrl).toBe('https://www.linkedin.com/in/johndoe/');
+      expect(options.includeContact).toBe(true);
+      expect(options.timeout).toBe(30000);
+    });
+
+    it('should allow options with only required fields', () => {
+      const options: ProfileExtractionOptions = {
+        profileUrl: 'https://www.linkedin.com/in/janedoe/',
+      };
+      expect(options.profileUrl).toBe('https://www.linkedin.com/in/janedoe/');
+      expect(options.includeContact).toBeUndefined();
+      expect(options.timeout).toBeUndefined();
+    });
+  });
+
+  describe('ProfileExtractionResult', () => {
+    it('should allow successful result with data', () => {
+      const result: ProfileExtractionResult = {
+        success: true,
+        message: 'Profile extracted successfully',
+        data: {
+          full_name: 'Test User',
+          headline: 'Test',
+          location: 'Test',
+          current_company: null,
+          current_title: null,
+          company_linkedin_url: null,
+          years_experience: null,
+          email: null,
+          phone: null,
+          profile_url: 'https://www.linkedin.com/in/testuser/',
+        },
+      };
+      expect(result.success).toBe(true);
+      expect(result.data?.full_name).toBe('Test User');
+    });
+
+    it('should allow failed result with error', () => {
+      const result: ProfileExtractionResult = {
+        success: false,
+        message: 'Failed to extract profile',
+        error: 'Profile not found',
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Profile not found');
+    });
+  });
+});

package/src/types/index.ts

@@ -0,0 +1,143 @@
+// Session types
+export interface Session {
+  cookies: Array<{
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    expires?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+  }>;
+  localStorage: Record<string, string>;
+  timestamp: Date;
+}
+
+// Message types
+export interface Message {
+  id: string;
+  threadId: string;
+  sender: {
+    name: string;
+    profileUrl?: string;
+    isMe: boolean;
+  };
+  content: string;
+  timestamp: Date;
+  isRead: boolean;
+}
+
+// New message sending types
+export interface SendMessageOptions {
+  profileUrl: string;
+  text: string;
+  dryRun?: boolean;
+}
+
+export interface SendMessageResult {
+  success: boolean;
+  messageId?: string;
+  threadId?: string;
+  error?: string;
+}
+
+export interface Thread {
+  id: string;
+  participants: Array<{
+    name: string;
+    profileUrl?: string;
+  }>;
+  messages: Message[];
+  lastActivity: Date;
+  unreadCount: number;
+}
+
+// Template types
+export interface Template {
+  id: string;
+  name: string;
+  description: string;
+  content: string;
+  variables: string[];
+  category: 'welcome' | 'followup' | 'meeting' | 'custom';
+}
+
+// Configuration types
+export interface Config {
+  headless: boolean;
+  rateLimit: number;
+  sessionTimeout: number;
+  dryRun: boolean;
+}
+
+// Audit log types
+export interface AuditLog {
+  timestamp: Date;
+  action: string;
+  details: Record<string, unknown>;
+  success: boolean;
+  error?: string;
+}
+
+// Company profile types
+export interface CompanyProfile {
+  name: string;
+  linkedin_url: string;
+  website: string | null;
+  industry: string | null;
+  company_size: string | null;
+  headquarters: string | null;
+  founded: string | null;
+  specialties: string[] | null;
+  type: string | null;
+  follower_count: number | null;
+}
+
+// ============================================================================
+// Profile Extraction Types
+// ============================================================================
+
+/**
+ * Profile data extracted from a LinkedIn profile
+ */
+export interface ProfileData {
+  // Top card fields
+  full_name: string;
+  headline: string;
+  location: string;
+
+  // Experience section
+  current_company: string | null;
+  current_title: string | null;
+  company_linkedin_url: string | null;
+
+  // Calculated
+  years_experience: number | null;
+
+  // Contact info (optional - requires clicking to reveal)
+  email: string | null;
+  phone: string | null;
+
+  // Reference
+  profile_url: string; // Canonical URL after LinkedIn redirects
+}
+
+/**
+ * Options for profile extraction
+ */
+export interface ProfileExtractionOptions {
+  profileUrl: string;
+  includeContact?: boolean;
+  timeout?: number;
+}
+
+/**
+ * Result of profile extraction following existing pattern
+ */
+export interface ProfileExtractionResult {
+  success: boolean;
+  message: string;
+  data?: ProfileData;
+  error?: string;
+}