intelwatch 1.2.0 → 1.3.2

package/src/license.js

@@ -0,0 +1,194 @@
+/**
+ * Freemium license gate for Intelwatch.
+ *
+ * License check order:
+ *   1. process.env.INTELWATCH_PRO_KEY
+ *   2. ~/.intelwatch-license (file containing license key)
+ *
+ * Pro features:
+ *   - XLS / PDF export
+ *   - Unlimited CSV rows (Free: capped at 50)
+ *   - Unlimited Reddit/HN results (Free: capped at 5)
+ *   - Full Pappers company profile (Free: --preview only)
+ *   - Full brand mention history
+ *
+ * The key is validated as a non-empty string. Actual server-side
+ * validation can be added later (e.g. license.recognity.fr/verify).
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import chalk from 'chalk';
+
+const LICENSE_FILE = join(homedir(), '.intelwatch-license');
+const LICENSE_FILE_ALT = join(homedir(), '.intelwatch-pro');
+const LICENSE_URL = 'https://recognity.fr/tools/intelwatch';
+
+// ── Limits ───────────────────────────────────────────────────────────────────
+
+export const FREE_LIMITS = {
+  csvMaxRows: 50,
+  redditMaxResults: 5,
+  hnMaxResults: 5,
+  pappersFullProfile: false,
+  exportFormats: ['json', 'csv'],
+};
+
+export const PRO_LIMITS = {
+  csvMaxRows: Infinity,
+  redditMaxResults: 100,
+  hnMaxResults: 100,
+  pappersFullProfile: true,
+  exportFormats: ['json', 'csv', 'xls', 'xlsx', 'excel', 'pdf'],
+};
+
+// ── Cache ────────────────────────────────────────────────────────────────────
+
+let _cachedKey = undefined;
+
+function readLicenseKey() {
+  if (_cachedKey !== undefined) return _cachedKey;
+
+  // 1. Environment variable
+  if (process.env.INTELWATCH_PRO_KEY) {
+    _cachedKey = process.env.INTELWATCH_PRO_KEY.trim();
+    return _cachedKey;
+  }
+
+  // 2. Legacy env var (backward compat with profile.js)
+  if (process.env.INTELWATCH_LICENSE_KEY) {
+    _cachedKey = process.env.INTELWATCH_LICENSE_KEY.trim();
+    return _cachedKey;
+  }
+
+  // 3. License file (~/.intelwatch-license or ~/.intelwatch-pro)
+  for (const file of [LICENSE_FILE, LICENSE_FILE_ALT]) {
+    if (existsSync(file)) {
+      try {
+        const content = readFileSync(file, 'utf8').trim();
+        if (content) {
+          _cachedKey = content;
+          return _cachedKey;
+        }
+      } catch {
+        // Ignore read errors
+      }
+    }
+  }
+
+  _cachedKey = null;
+  return _cachedKey;
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Check if the user has a Pro license.
+ */
+export function isPro() {
+  return !!readLicenseKey();
+}
+
+/**
+ * Get the current license key (or null).
+ */
+export function getLicenseKey() {
+  return readLicenseKey();
+}
+
+/**
+ * Get the limits for the current tier.
+ */
+export function getLimits() {
+  return isPro() ? PRO_LIMITS : FREE_LIMITS;
+}
+
+/**
+ * Assert that a Pro feature is available. Throws if not.
+ * @param {string} featureName — human-readable feature name for the error message
+ */
+export function requirePro(featureName) {
+  if (isPro()) return;
+  const msg = `${featureName} requires an Intelwatch Pro license.`;
+  const err = new Error(msg);
+  err.code = 'LICENSE_REQUIRED';
+  err.featureName = featureName;
+  throw err;
+}
+
+/**
+ * Print a Pro upgrade message to stderr (non-blocking, doesn't throw).
+ * @param {string} featureName
+ */
+export function printProUpgrade(featureName) {
+  console.error('');
+  console.error(chalk.yellow(`  ⚡ ${featureName} — Pro Feature`));
+  console.error(chalk.gray(`     Upgrade to Intelwatch Pro for full access.`));
+  console.error(chalk.gray(`     ${LICENSE_URL}`));
+  console.error(chalk.gray(`     Set INTELWATCH_PRO_KEY or create ~/.intelwatch-license`));
+  console.error('');
+}
+
+/**
+ * Gate a Pro feature: if not Pro, print upgrade message and return false.
+ * @param {string} featureName
+ * @returns {boolean} true if Pro, false otherwise
+ */
+export function gatePro(featureName) {
+  if (isPro()) return true;
+  printProUpgrade(featureName);
+  return false;
+}
+
+/**
+ * Truncate an array to Free-tier limit with a warning.
+ * @param {Array} data
+ * @param {number} freeLimit
+ * @param {string} featureName
+ * @returns {Array}
+ */
+export function applyFreeLimit(data, freeLimit, featureName) {
+  if (!Array.isArray(data)) return data;
+  if (isPro() || data.length <= freeLimit) return data;
+
+  console.error(chalk.yellow(`  ⚠️  Free tier: showing ${freeLimit}/${data.length} results. Upgrade to Pro for unlimited ${featureName}.`));
+  return data.slice(0, freeLimit);
+}
+
+/**
+ * Save a license key to ~/.intelwatch-pro and refresh the cache.
+ * @param {string} key
+ */
+export function saveLicenseKey(key) {
+  const trimmed = (key || '').trim();
+  if (!trimmed) {
+    throw new Error('License key cannot be empty.');
+  }
+  writeFileSync(LICENSE_FILE_ALT, trimmed + '\n', 'utf8');
+  _cachedKey = undefined; // bust cache
+  return LICENSE_FILE_ALT;
+}
+
+/**
+ * Print a clean paywall block and exit the process (non-throwing).
+ * Use this instead of requirePro when you want a user-friendly exit.
+ * @param {string} featureName
+ */
+export function printPaywallAndExit(featureName) {
+  console.error('');
+  console.error(chalk.red('  🔒 This is a Pro feature!'));
+  console.error(chalk.yellow(`     "${featureName}" requires an Intelwatch Pro license.`));
+  console.error('');
+  console.error(chalk.gray('     Upgrade at ') + chalk.cyan.underline(LICENSE_URL));
+  console.error(chalk.gray('     Then run: ') + chalk.white('intelwatch auth <key>'));
+  console.error('');
+  process.exit(0);
+}
+
+/**
+ * Reset cached license (for testing).
+ */
+export function _resetCache() {
+  _cachedKey = undefined;
+}

package/src/providers/apollo.js

@@ -0,0 +1,172 @@
+/**
+ * Apollo Provider — International company enrichment (BYOK).
+ *
+ * API: https://apolloapi.io/developers
+ * Requires APOLLO_API_KEY.
+ *
+ * Provides:
+ *   - Domain → company enrichment (name, sector, employee count, revenue, tech)
+ *   - Good for .com / international where Pappers doesn't work
+ *   - Complements Clearbit with similar enrichment capabilities
+ *
+ * All Apollo queries are Pro-only (license gate in registry.js).
+ */
+
+import { fetch } from '../utils/fetcher.js';
+
+const APOLLO_API = 'https://api.apollo.io/v1';
+
+function getApiKey() {
+  return process.env.APOLLO_API_KEY || null;
+}
+
+const apolloProvider = {
+  name: 'apollo',
+  country: 'INTL',
+  description: 'Apollo.io — Domain-based company enrichment (sector, size, tech, revenue)',
+
+  isAvailable() {
+    return !!getApiKey();
+  },
+
+  /**
+   * Search companies by name or domain.
+   * @param {string} query
+   * @param {{ count?: number }} options
+   * @returns {Promise<{ results: Array, error: string|null }>}
+   */
+  async search(query, options = {}) {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      return { results: [], error: 'APOLLO_API_KEY not set.' };
+    }
+
+    try {
+      const body = {
+        q_organization_name: query,
+        per_page: Math.min(options.count || 10, 25),
+      };
+
+      const resp = await fetch(`${APOLLO_API}/mixed_companies/search`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Cache-Control': 'no-cache',
+          'X-Api-Key': apiKey,
+        },
+        data: JSON.stringify(body),
+        timeout: 15000,
+      });
+
+      const data = typeof resp.data === 'string' ? JSON.parse(resp.data) : resp.data;
+      const orgs = data?.organizations || [];
+
+      const results = orgs.map(c => ({
+        name: c.name,
+        domain: c.primary_domain,
+        sector: c.industry,
+        employeeRange: c.estimated_num_employees ? `${c.estimated_num_employees}` : null,
+        estimatedRevenue: c.annual_revenue_printed,
+        description: c.short_description,
+        foundedYear: c.founded_year,
+        location: [c.city, c.state, c.country].filter(Boolean).join(', '),
+        country: c.country,
+        logo: c.logo_url,
+        url: c.website_url || (c.primary_domain ? `https://${c.primary_domain}` : null),
+        linkedin: c.linkedin_url,
+        phone: c.phone,
+        source: 'apollo',
+      }));
+
+      return { results, error: null };
+    } catch (err) {
+      return { results: [], error: err.message };
+    }
+  },
+
+  /**
+   * Get company profile by domain.
+   * @param {string} domain — e.g. "stripe.com"
+   * @param {{ preview?: boolean }} options
+   * @returns {Promise<{ data: object|null, error: string|null }>}
+   */
+  async getProfile(domain, options = {}) {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      return { data: null, error: 'APOLLO_API_KEY not set.' };
+    }
+
+    try {
+      const cleanDomain = domain.replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0];
+
+      const resp = await fetch(`${APOLLO_API}/organizations/enrich`, {
+        method: 'GET',
+        headers: {
+          'Cache-Control': 'no-cache',
+          'X-Api-Key': apiKey,
+        },
+        params: { domain: cleanDomain },
+        timeout: 15000,
+      });
+
+      const data = typeof resp.data === 'string' ? JSON.parse(resp.data) : resp.data;
+      const c = data?.organization;
+
+      if (!c) {
+        return { data: null, error: 'Company not found on Apollo' };
+      }
+
+      const profile = {
+        name: c.name,
+        legalName: c.name,
+        domain: c.primary_domain || cleanDomain,
+        sector: c.industry,
+        subIndustry: c.sub_industry,
+        employeeRange: c.estimated_num_employees ? `${c.estimated_num_employees}` : null,
+        estimatedRevenue: c.annual_revenue_printed,
+        raised: c.total_funding_printed,
+        description: c.short_description,
+        foundedYear: c.founded_year,
+        location: [c.city, c.state, c.country].filter(Boolean).join(', '),
+        country: c.country,
+        logo: c.logo_url,
+        techStack: c.current_technologies?.map(t => t.name) || [],
+        tags: c.keywords || [],
+        url: c.website_url || `https://${cleanDomain}`,
+        linkedin: c.linkedin_url,
+        twitter: c.twitter_url,
+        facebook: c.facebook_url,
+        phone: c.phone,
+        source: 'apollo',
+      };
+
+      return { data: profile, error: null };
+    } catch (err) {
+      return { data: null, error: err.message };
+    }
+  },
+
+  /**
+   * No subsidiary data from Apollo.
+   */
+  async getSubsidiaries() {
+    return {
+      subsidiaries: [],
+      error: 'Apollo does not provide subsidiary data.',
+    };
+  },
+
+  /**
+   * Quick lookup by domain.
+   */
+  async lookup(companyNameOrDomain) {
+    if (!this.isAvailable()) return null;
+    const domain = companyNameOrDomain.includes('.')
+      ? companyNameOrDomain
+      : `${companyNameOrDomain.toLowerCase().replace(/\s+/g, '')}.com`;
+    const result = await this.getProfile(domain, { preview: true });
+    return result.data;
+  },
+};
+
+export default apolloProvider;

package/src/providers/clearbit.js

@@ -0,0 +1,136 @@
+/**
+ * Clearbit Provider — International company enrichment (BYOK).
+ *
+ * API: https://dashboard.clearbit.com/docs
+ * Requires CLEARBIT_API_KEY.
+ *
+ * Provides:
+ *   - Domain → company enrichment (name, sector, employee count, revenue range, tech stack)
+ *   - Good for .com / international where Pappers doesn't work
+ *   - Complements OpenCorporates (OC = registry data, Clearbit = market data)
+ *
+ * This is a scaffold ready for BYOK integration.
+ */
+
+import { fetch } from '../utils/fetcher.js';
+
+const CLEARBIT_API = 'https://company.clearbit.com/v2';
+
+function getApiKey() {
+  return process.env.CLEARBIT_API_KEY || null;
+}
+
+const clearbitProvider = {
+  name: 'clearbit',
+  country: 'INTL',
+  description: 'Clearbit — Domain-based company enrichment (sector, size, tech, revenue)',
+
+  isAvailable() {
+    return !!getApiKey();
+  },
+
+  /**
+   * Search is not the primary Clearbit use case — use domain enrichment instead.
+   * Falls back to domain lookup if query looks like a domain.
+   */
+  async search(query, options = {}) {
+    // Clearbit's primary API is domain-based, not name-based
+    if (query.includes('.')) {
+      // Looks like a domain — use enrichment
+      const profile = await this.getProfile(query);
+      if (profile.data) {
+        return { results: [profile.data], error: null };
+      }
+    }
+
+    return {
+      results: [],
+      error: 'Clearbit requires a domain for lookup. Try with a domain (e.g., company.com).',
+    };
+  },
+
+  /**
+   * Get company profile by domain.
+   * @param {string} domain — e.g. "stripe.com"
+   * @param {{ preview?: boolean }} options
+   * @returns {Promise<{ data: object|null, error: string|null }>}
+   */
+  async getProfile(domain, options = {}) {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      return { data: null, error: 'CLEARBIT_API_KEY not set.' };
+    }
+
+    try {
+      // Clean domain
+      const cleanDomain = domain.replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0];
+
+      const resp = await fetch(`${CLEARBIT_API}/companies/find?domain=${cleanDomain}`, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: 'application/json',
+        },
+        timeout: 15000,
+      });
+
+      if (resp.status === 404) {
+        return { data: null, error: 'Company not found on Clearbit' };
+      }
+
+      const c = typeof resp.data === 'string' ? JSON.parse(resp.data) : resp.data;
+
+      const profile = {
+        name: c.name,
+        legalName: c.legalName,
+        domain: c.domain,
+        sector: c.category?.sector,
+        industry: c.category?.industry,
+        subIndustry: c.category?.subIndustry,
+        employeeRange: c.metrics?.employeesRange,
+        estimatedRevenue: c.metrics?.estimatedAnnualRevenue,
+        raised: c.metrics?.raised,
+        description: c.description,
+        foundedYear: c.foundedYear,
+        location: c.geo ? `${c.geo.city}, ${c.geo.country}` : null,
+        country: c.geo?.country,
+        logo: c.logo,
+        techStack: c.tech || [],
+        tags: c.tags || [],
+        url: `https://${c.domain}`,
+        linkedin: c.linkedin?.handle ? `https://linkedin.com/company/${c.linkedin.handle}` : null,
+        twitter: c.twitter?.handle ? `https://twitter.com/${c.twitter.handle}` : null,
+        facebook: c.facebook?.handle ? `https://facebook.com/${c.facebook.handle}` : null,
+        source: 'clearbit',
+      };
+
+      return { data: profile, error: null };
+    } catch (err) {
+      return { data: null, error: err.message };
+    }
+  },
+
+  /**
+   * No subsidiary data from Clearbit.
+   */
+  async getSubsidiaries() {
+    return {
+      subsidiaries: [],
+      error: 'Clearbit does not provide subsidiary data.',
+    };
+  },
+
+  /**
+   * Quick lookup by domain.
+   */
+  async lookup(companyNameOrDomain) {
+    if (!this.isAvailable()) return null;
+    // Best used with domains
+    const domain = companyNameOrDomain.includes('.')
+      ? companyNameOrDomain
+      : `${companyNameOrDomain.toLowerCase().replace(/\s+/g, '')}.com`;
+    const result = await this.getProfile(domain, { preview: true });
+    return result.data;
+  },
+};
+
+export default clearbitProvider;

package/src/providers/index.js

@@ -0,0 +1,30 @@
+/**
+ * Provider auto-registration.
+ *
+ * Import this module once at CLI startup to register all company data providers.
+ *
+ * Usage:
+ *   import './providers/index.js';              // registers all
+ *   import { resolveProvider } from './providers/registry.js';  // use
+ */
+
+import { registerProvider } from './registry.js';
+import pappersProvider from './pappers.js';
+import opencorporatesProvider from './opencorporates.js';
+import clearbitProvider from './clearbit.js';
+import apolloProvider from './apollo.js';
+
+registerProvider('pappers', pappersProvider);
+registerProvider('opencorporates', opencorporatesProvider);
+registerProvider('clearbit', clearbitProvider);
+registerProvider('apollo', apolloProvider);
+
+export {
+  detectCountry,
+  resolveProvider,
+  searchCompany,
+  getCompanyProfile,
+  getSubsidiaries,
+  lookupCompany,
+  listProviders,
+} from './registry.js';

package/src/providers/opencorporates.js

@@ -0,0 +1,159 @@
+/**
+ * OpenCorporates Provider — International company data.
+ *
+ * API: https://api.opencorporates.com/v0.4/
+ * Free tier: 500 req/month, basic data (name, jurisdiction, status, incorporation date)
+ * Pro tier (BYOK): full data, officers, filings, statements
+ *
+ * This is a scaffold with real API integration for search and basic profile.
+ * Full enrichment (officers, filings) can be added incrementally.
+ */
+
+import { fetch } from '../utils/fetcher.js';
+
+const OC_API = 'https://api.opencorporates.com/v0.4';
+
+function getApiKey() {
+  return process.env.OPENCORPORATES_API_KEY || null;
+}
+
+const opencorporatesProvider = {
+  name: 'opencorporates',
+  country: 'INTL',
+  description: 'OpenCorporates — International company registry (180+ jurisdictions)',
+
+  /**
+   * OpenCorporates has a free tier (no key needed, 500/month).
+   * With API key → higher limits + more data.
+   */
+  isAvailable() {
+    // Always available (free tier exists), but limited without key
+    return true;
+  },
+
+  /**
+   * Search companies by name.
+   * @param {string} query
+   * @param {{ count?: number, jurisdiction?: string }} options
+   * @returns {Promise<{ results: Array, error: string|null }>}
+   */
+  async search(query, options = {}) {
+    try {
+      const params = new URLSearchParams({ q: query });
+      if (options.jurisdiction) params.set('jurisdiction_code', options.jurisdiction);
+      if (options.count) params.set('per_page', String(Math.min(options.count, 30)));
+      const apiKey = getApiKey();
+      if (apiKey) params.set('api_token', apiKey);
+
+      const resp = await fetch(`${OC_API}/companies/search?${params}`, {
+        headers: { Accept: 'application/json' },
+        timeout: 15000,
+      });
+
+      const data = typeof resp.data === 'string' ? JSON.parse(resp.data) : resp.data;
+      const companies = data?.results?.companies || [];
+
+      const results = companies.map(({ company: c }) => ({
+        name: c.name,
+        companyNumber: c.company_number,
+        jurisdiction: c.jurisdiction_code,
+        status: c.current_status,
+        incorporationDate: c.incorporation_date,
+        companyType: c.company_type,
+        registeredAddress: c.registered_address_in_full,
+        url: c.opencorporates_url,
+        source: 'opencorporates',
+      }));
+
+      return { results, error: null };
+    } catch (err) {
+      return { results: [], error: err.message };
+    }
+  },
+
+  /**
+   * Get company profile by jurisdiction + company number.
+   * @param {string} identifier — format: "jurisdiction/company_number" e.g. "gb/12345678"
+   * @param {{ preview?: boolean }} options
+   * @returns {Promise<{ data: object|null, error: string|null }>}
+   */
+  async getProfile(identifier, options = {}) {
+    try {
+      // Identifier can be "gb/12345678" or just a company number
+      const path = identifier.includes('/') ? identifier : `us_${identifier}`;
+      const params = new URLSearchParams();
+      const apiKey = getApiKey();
+      if (apiKey) params.set('api_token', apiKey);
+
+      const resp = await fetch(`${OC_API}/companies/${path}?${params}`, {
+        headers: { Accept: 'application/json' },
+        timeout: 15000,
+      });
+
+      const data = typeof resp.data === 'string' ? JSON.parse(resp.data) : resp.data;
+      const c = data?.results?.company;
+
+      if (!c) return { data: null, error: 'Company not found' };
+
+      const profile = {
+        name: c.name,
+        companyNumber: c.company_number,
+        jurisdiction: c.jurisdiction_code,
+        status: c.current_status,
+        incorporationDate: c.incorporation_date,
+        dissolutionDate: c.dissolution_date,
+        companyType: c.company_type,
+        registeredAddress: c.registered_address_in_full,
+        previousNames: (c.previous_names || []).map(pn => pn.company_name),
+        agentName: c.agent_name,
+        agentAddress: c.agent_address,
+        url: c.opencorporates_url,
+        source: 'opencorporates',
+        // Officers and filings available with Pro key
+        officerCount: c.number_of_employees || null,
+        ...(options.preview ? {} : {
+          officers: (c.officers || []).map(o => ({
+            name: o.officer?.name,
+            position: o.officer?.position,
+            startDate: o.officer?.start_date,
+            endDate: o.officer?.end_date,
+          })),
+          filings: (c.filings || []).slice(0, 20).map(f => ({
+            title: f.filing?.title,
+            date: f.filing?.date,
+            type: f.filing?.filing_type,
+            url: f.filing?.opencorporates_url,
+          })),
+        }),
+      };
+
+      return { data: profile, error: null };
+    } catch (err) {
+      return { data: null, error: err.message };
+    }
+  },
+
+  /**
+   * Subsidiary lookup — not directly supported by OC free tier.
+   * Returns empty with a note.
+   */
+  async getSubsidiaries(parentName, parentId, options = {}) {
+    return {
+      subsidiaries: [],
+      error: 'OpenCorporates does not provide subsidiary data in the free tier. Use a jurisdiction-specific provider for subsidiary analysis.',
+    };
+  },
+
+  /**
+   * Quick lookup for competitor tracker.
+   */
+  async lookup(companyName) {
+    const result = await this.search(companyName, { count: 1 });
+    if (result.results.length > 0) {
+      return result.results[0];
+    }
+    return null;
+  },
+};
+
+export default opencorporatesProvider;