gtm-now 0.10.10 → 0.10.11

package/dist/index.js

@@ -205,7 +205,8 @@ var init_config = __esm({
       GTM_SMARTLEAD_API_KEY: "smartlead",
       GTM_HARVEST_API_KEY: "harvest",
       GTM_STORELEADS_API_KEY: "storeleads",
-      GTM_EXA_API_KEY: "exa"
+      GTM_EXA_API_KEY: "exa",
+      GTM_LEADMAGIC_API_KEY: "leadmagic"
     };
     ENV_WORKSPACE_MAP = {
       GTM_PLUSVIBE_WORKSPACE_ID: "plusvibe"
@@ -8738,10 +8739,107 @@ var init_client25 = __esm({
 });
 
 // ../integrations/dist/leadmagic.js
+var LeadMagicClient;
 var init_leadmagic2 = __esm({
   "../integrations/dist/leadmagic.js"() {
     "use strict";
     init_base_client();
+    LeadMagicClient = class extends BaseApiClient {
+      constructor(config) {
+        super({
+          name: "LeadMagic",
+          baseUrl: config.baseUrl ?? "https://api.leadmagic.io",
+          headers: { "X-API-Key": config.apiKey },
+          timeoutMs: config.timeoutMs
+        });
+      }
+      // ─── People ──────────────────────────────────────────────────────────────────
+      async findEmail(params) {
+        return this.request("/v1/people/email-finder", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async validateEmail(params) {
+        return this.request("/v1/people/email-validation", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async findMobile(params) {
+        return this.request("/v1/people/mobile-finder", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async searchProfile(params) {
+        return this.request("/v1/people/profile-search", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async findEmployees(params) {
+        return this.request("/v1/people/employee-finder", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async findRole(params) {
+        return this.request("/v1/people/role-finder", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async emailToProfile(params) {
+        return this.request("/v1/people/b2b-profile", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async profileToEmail(params) {
+        return this.request("/v1/people/b2b-profile-email", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async findPersonalEmail(params) {
+        return this.request("/v1/people/personal-email-finder", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async detectJobChange(params) {
+        return this.request("/v1/people/job-change-detector", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      // ─── Companies ───────────────────────────────────────────────────────────────
+      async searchCompany(params) {
+        return this.request("/v1/companies/company-search", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async searchCompetitors(params) {
+        return this.request("/v1/companies/competitors-search", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async getCompanyFunding(params) {
+        return this.request("/v1/companies/company-funding", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      async getTechnographics(params) {
+        return this.request("/v1/companies/technographics", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+    };
   }
 });
 
@@ -10559,6 +10657,195 @@ var init_exa = __esm({
   }
 });
 
+// src/providers/adapters/leadmagic.ts
+function mapEmailQuality(status) {
+  switch (status) {
+    case "valid":
+      return "95%";
+    case "valid_catch_all":
+      return "80%";
+    case "catch_all":
+      return "60%";
+    default:
+      return "50%";
+  }
+}
+function mapVerificationStatus(status) {
+  switch (status) {
+    case "valid":
+      return "deliverable";
+    case "valid_catch_all":
+      return "catch_all_safe";
+    case "catch_all":
+      return "catch_all_not_safe";
+    case "invalid":
+      return "undeliverable";
+    default:
+      return "unknown";
+  }
+}
+var LeadMagicAdapter2;
+var init_leadmagic3 = __esm({
+  "src/providers/adapters/leadmagic.ts"() {
+    "use strict";
+    init_dist();
+    init_dist2();
+    LeadMagicAdapter2 = class {
+      name = "leadmagic";
+      capabilities = [
+        "enrich_email",
+        "enrich_phone",
+        "verify_email",
+        "find_people"
+      ];
+      notes = "Best for: email enrichment (name+domain), email validation (0.05 credits), mobile finder (needs LinkedIn URL, 5 credits), employee lists (0.05/employee). Also supports: profile search, company search, technographics, funding, competitors, job change detection. Pay-on-find pricing \u2014 free when no result.";
+      client;
+      constructor(apiKey) {
+        this.client = new LeadMagicClient({ apiKey });
+      }
+      async checkCredentials() {
+        try {
+          await this.client.validateEmail({ email: "test@example.com" });
+          return true;
+        } catch (error) {
+          logError(
+            "leadmagic:checkCredentials",
+            error instanceof Error ? error : new Error(String(error))
+          );
+          return false;
+        }
+      }
+      async checkCredits() {
+        return null;
+      }
+      // ─── EmailEnricher ──────────────────────────────────────
+      async enrichEmail(contact) {
+        try {
+          if (contact.first_name && contact.last_name && (contact.company_domain || contact.company)) {
+            const response = await this.client.findEmail({
+              first_name: contact.first_name,
+              last_name: contact.last_name,
+              domain: contact.company_domain,
+              company_name: !contact.company_domain ? contact.company : void 0
+            });
+            if (response.email && response.status !== "not_found") {
+              return {
+                email: response.email,
+                quality: mapEmailQuality(response.status),
+                provider: this.name,
+                credits_consumed: response.credits_consumed
+              };
+            }
+          }
+          if (contact.linkedin_url) {
+            const response = await this.client.profileToEmail({
+              profile_url: contact.linkedin_url
+            });
+            if (response.email) {
+              return {
+                email: response.email,
+                quality: "80%",
+                // Profile-to-email doesn't return validation status
+                provider: this.name,
+                credits_consumed: response.credits_consumed
+              };
+            }
+          }
+          return null;
+        } catch (error) {
+          logError("leadmagic:enrichEmail", error instanceof Error ? error : new Error(String(error)));
+          return null;
+        }
+      }
+      // ─── PhoneEnricher ──────────────────────────────────────
+      async enrichPhone(contact) {
+        try {
+          const response = await this.client.findMobile({
+            profile_url: contact.linkedin_url,
+            work_email: void 0,
+            // Could pass email if available
+            personal_email: void 0
+          });
+          if (!response.mobile_number) return null;
+          return {
+            phone: response.mobile_number,
+            provider: this.name
+          };
+        } catch (error) {
+          logError("leadmagic:enrichPhone", error instanceof Error ? error : new Error(String(error)));
+          return null;
+        }
+      }
+      // ─── EmailVerifier ──────────────────────────────────────
+      async verifyEmail(email) {
+        try {
+          const response = await this.client.validateEmail({ email });
+          return {
+            email: response.email ?? email,
+            valid: response.email_status === "valid" || response.email_status === "valid_catch_all",
+            status: mapVerificationStatus(response.email_status),
+            provider: this.name
+          };
+        } catch (error) {
+          logError("leadmagic:verifyEmail", error instanceof Error ? error : new Error(String(error)));
+          return {
+            email,
+            valid: false,
+            status: "unknown",
+            provider: this.name
+          };
+        }
+      }
+      // ─── PeopleFinder ───────────────────────────────────────
+      async findPeople(query) {
+        try {
+          if (query.job_title && (query.company_domain || query.company_name)) {
+            const response = await this.client.findRole({
+              job_title: query.job_title,
+              company_domain: query.company_domain,
+              company_name: !query.company_domain ? query.company_name : void 0
+            });
+            if (response.first_name && response.last_name) {
+              return [
+                {
+                  first_name: response.first_name,
+                  last_name: response.last_name,
+                  job_title: response.job_title ?? void 0,
+                  company: response.company_name ?? void 0,
+                  company_domain: response.company_website ?? query.company_domain ?? void 0,
+                  linkedin_url: response.profile_url ?? void 0,
+                  sources: [this.name]
+                }
+              ];
+            }
+            return [];
+          }
+          if (query.company_domain || query.company_name) {
+            const response = await this.client.findEmployees({
+              company_domain: query.company_domain,
+              company_name: !query.company_domain ? query.company_name : void 0,
+              limit: query.limit ?? 20
+            });
+            if (!response.data?.length) return [];
+            return response.data.map((emp) => ({
+              first_name: emp.first_name ?? "",
+              last_name: emp.last_name ?? "",
+              job_title: emp.title ?? void 0,
+              company: emp.company_name ?? void 0,
+              company_domain: emp.website ?? query.company_domain ?? void 0,
+              sources: [this.name]
+            }));
+          }
+          return [];
+        } catch (error) {
+          logError("leadmagic:findPeople", error instanceof Error ? error : new Error(String(error)));
+          return [];
+        }
+      }
+    };
+  }
+});
+
 // src/providers/adapters/index.ts
 var init_adapters = __esm({
   "src/providers/adapters/index.ts"() {
@@ -10576,6 +10863,7 @@ var init_adapters = __esm({
     init_storeleads();
     init_harvest();
     init_exa();
+    init_leadmagic3();
   }
 });
 
@@ -10608,6 +10896,8 @@ function createAdapter(name, config) {
       return config.api_key ? new HarvestApiAdapter(config.api_key) : null;
     case "exa":
       return config.api_key ? new ExaAdapter(config.api_key) : null;
+    case "leadmagic":
+      return config.api_key ? new LeadMagicAdapter2(config.api_key) : null;
     default:
       return null;
   }
@@ -11154,7 +11444,20 @@ var init_extract = __esm({
             },
             profile: {
               type: "string",
-              description: "LinkedIn URL or publicIdentifier (required for linkedin_posts)"
+              description: "LinkedIn URL or publicIdentifier (required for linkedin_posts, single profile)"
+            },
+            profiles: {
+              type: "array",
+              items: { type: "string" },
+              description: "Batch mode: array of LinkedIn URLs or publicIdentifiers. Checks each for recent posts concurrently. Returns lightweight results (posted/not, count, last date). Use with posted_within to filter for recent activity."
+            },
+            csv_file: {
+              type: "string",
+              description: 'Path to a CSV file containing LinkedIn profile URLs. Reads the "LinkedIn Profile" or "linkedin_url" column automatically. Alternative to profiles[] for large lists.'
+            },
+            concurrency: {
+              type: "number",
+              description: "Max concurrent API requests for batch mode (default: 5, max: 20). Higher = faster but more likely to hit rate limits."
             },
             company: {
               type: "string",
@@ -11193,6 +11496,15 @@ var init_extract = __esm({
               type: "string",
               enum: ["summary", "full"],
               description: 'Response detail level. "summary" (default) returns counts and key fields only \u2014 truncates post text, omits individual engagement items. "full" returns complete data including all post content and engager lists.'
+            },
+            output: {
+              type: "string",
+              enum: ["file", "csv", "inline"],
+              description: 'Output mode for batch results. "csv" writes a CSV file (default for batch). "file" writes JSONL. "inline" returns in response (only for small batches).'
+            },
+            review: {
+              type: "boolean",
+              description: "Create a viewer table with batch results for human review."
             }
           }
         }
@@ -13017,6 +13329,7 @@ var extract_exports = {};
 __export(extract_exports, {
   handleExtract: () => handleExtract
 });
+import * as fs2 from "fs";
 function slimPost(post) {
   const slim = {};
   for (const [key, value] of Object.entries(post)) {
@@ -13097,6 +13410,11 @@ async function handleLinkedinExtract(type, args, ctx) {
       };
     }
     case "linkedin_posts": {
+      const profiles = args.profiles;
+      const csvFile = args.csv_file;
+      if (profiles?.length || csvFile) {
+        return handleBatchLinkedinPosts(args, adapter);
+      }
       const result = await adapter.getProfilePosts({
         profile: args.profile,
         postedLimit: args.posted_within
@@ -13161,12 +13479,234 @@ async function handleLinkedinExtract(type, args, ctx) {
       throw new Error(`Unknown extract type: ${type}`);
   }
 }
-var POST_TEXT_LIMIT;
+async function handleBatchLinkedinPosts(args, adapter) {
+  const profilesArg = args.profiles;
+  const csvFile = args.csv_file;
+  const postedWithin = args.posted_within ?? "month";
+  const concurrency = Math.min(
+    args.concurrency ?? DEFAULT_BATCH_CONCURRENCY,
+    MAX_BATCH_CONCURRENCY
+  );
+  const output = args.output;
+  const shouldReview = args.review ?? false;
+  let profiles;
+  if (csvFile) {
+    profiles = parseCsvProfiles(csvFile);
+  } else {
+    profiles = (profilesArg ?? []).map((url) => ({ linkedin_url: url }));
+  }
+  if (profiles.length === 0) {
+    throw createGtmError("EXTRACTION_FAILED", "No LinkedIn profiles found in input.");
+  }
+  const results = new Array(profiles.length);
+  let nextIndex = 0;
+  let completed = 0;
+  const deadline = Date.now() + BATCH_TIMEOUT_MS;
+  async function worker() {
+    while (nextIndex < profiles.length) {
+      const i = nextIndex++;
+      const entry = profiles[i];
+      if (Date.now() > deadline) {
+        results[i] = {
+          linkedin_url: entry.linkedin_url,
+          name: entry.name,
+          company: entry.company,
+          has_posts: false,
+          post_count: 0,
+          error: "timeout"
+        };
+        completed++;
+        continue;
+      }
+      try {
+        const result = await adapter.getProfilePosts({
+          profile: entry.linkedin_url,
+          postedLimit: postedWithin
+        });
+        const posts = result.elements;
+        let lastPostDate;
+        if (posts.length > 0) {
+          const first = posts[0];
+          lastPostDate = first.postedAt ?? first.postedDate ?? first.posted_at;
+        }
+        results[i] = {
+          linkedin_url: entry.linkedin_url,
+          name: entry.name,
+          company: entry.company,
+          has_posts: posts.length > 0,
+          post_count: posts.length,
+          last_post_date: lastPostDate
+        };
+      } catch (error) {
+        logError("extract:batchLinkedinPosts", error instanceof Error ? error : new Error(String(error)), {
+          profile: entry.linkedin_url
+        });
+        results[i] = {
+          linkedin_url: entry.linkedin_url,
+          name: entry.name,
+          company: entry.company,
+          has_posts: false,
+          post_count: 0,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+      completed++;
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, profiles.length) }, () => worker())
+  );
+  const activeProfiles = results.filter((r) => r.has_posts);
+  const errors = results.filter((r) => r.error);
+  let tableId;
+  let tableUrl;
+  if (shouldReview) {
+    const tableResult = await createReviewTable(
+      `LinkedIn Activity Check (${postedWithin})`,
+      results
+    );
+    if (tableResult) {
+      tableId = tableResult.table_id;
+      tableUrl = tableResult.url;
+    }
+  }
+  const effectiveOutput = output ?? (profiles.length > 20 ? "csv" : "inline");
+  if (effectiveOutput === "csv") {
+    const filePath = writeResultsCsv(
+      "linkedin_activity",
+      results
+    );
+    return {
+      type: "linkedin_posts_batch",
+      provider: "harvest",
+      total: profiles.length,
+      active: activeProfiles.length,
+      inactive: profiles.length - activeProfiles.length - errors.length,
+      errors: errors.length,
+      posted_within: postedWithin,
+      output: "csv",
+      file: filePath,
+      preview: activeProfiles.slice(0, 5),
+      ...tableId && { table_id: tableId, url: tableUrl }
+    };
+  }
+  if (effectiveOutput === "file") {
+    const filePath = writeResultsFile(
+      "linkedin_activity",
+      results,
+      { query: { posted_within: postedWithin }, provider: "harvest", count: results.length, has_more: false }
+    );
+    return {
+      type: "linkedin_posts_batch",
+      provider: "harvest",
+      total: profiles.length,
+      active: activeProfiles.length,
+      inactive: profiles.length - activeProfiles.length - errors.length,
+      errors: errors.length,
+      posted_within: postedWithin,
+      output: "file",
+      file: filePath,
+      preview: activeProfiles.slice(0, 5),
+      ...tableId && { table_id: tableId, url: tableUrl }
+    };
+  }
+  return {
+    type: "linkedin_posts_batch",
+    provider: "harvest",
+    total: profiles.length,
+    active: activeProfiles.length,
+    inactive: profiles.length - activeProfiles.length - errors.length,
+    errors: errors.length,
+    posted_within: postedWithin,
+    results,
+    ...tableId && { table_id: tableId, url: tableUrl }
+  };
+}
+function parseCsvProfiles(filePath) {
+  if (!fs2.existsSync(filePath)) {
+    throw createGtmError("EXTRACTION_FAILED", `CSV file not found: ${filePath}`);
+  }
+  const content = fs2.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter((line) => line.trim().length > 0);
+  if (lines.length < 2) {
+    throw createGtmError("EXTRACTION_FAILED", "CSV file has no data rows.");
+  }
+  const headerLine = lines[0];
+  const headers = parseCsvLine(headerLine).map((h) => h.toLowerCase().trim());
+  const linkedinIdx = headers.findIndex((h) => LINKEDIN_URL_COLUMNS.includes(h));
+  if (linkedinIdx === -1) {
+    throw createGtmError(
+      "EXTRACTION_FAILED",
+      `No LinkedIn URL column found in CSV. Expected one of: ${LINKEDIN_URL_COLUMNS.join(", ")}. Found columns: ${headers.join(", ")}`
+    );
+  }
+  const nameIdx = headers.findIndex((h) => NAME_COLUMNS.includes(h));
+  const companyIdx = headers.findIndex((h) => COMPANY_COLUMNS.includes(h));
+  const entries = [];
+  for (let i = 1; i < lines.length; i++) {
+    const fields = parseCsvLine(lines[i]);
+    const url = fields[linkedinIdx]?.trim();
+    if (!url || !url.includes("linkedin.com")) continue;
+    entries.push({
+      linkedin_url: url,
+      name: nameIdx >= 0 ? fields[nameIdx]?.trim() : void 0,
+      company: companyIdx >= 0 ? fields[companyIdx]?.trim() : void 0
+    });
+  }
+  return entries;
+}
+function parseCsvLine(line) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === '"') {
+        if (i + 1 < line.length && line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        current += char;
+      }
+    } else if (char === '"') {
+      inQuotes = true;
+    } else if (char === ",") {
+      fields.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  fields.push(current);
+  return fields;
+}
+var POST_TEXT_LIMIT, DEFAULT_BATCH_CONCURRENCY, MAX_BATCH_CONCURRENCY, BATCH_TIMEOUT_MS, LINKEDIN_URL_COLUMNS, NAME_COLUMNS, COMPANY_COLUMNS;
 var init_extract2 = __esm({
   "src/handlers/extract.ts"() {
     "use strict";
+    init_dist();
     init_errors();
+    init_table_bridge();
+    init_result_writer();
     POST_TEXT_LIMIT = 200;
+    DEFAULT_BATCH_CONCURRENCY = 5;
+    MAX_BATCH_CONCURRENCY = 20;
+    BATCH_TIMEOUT_MS = 10 * 60 * 1e3;
+    LINKEDIN_URL_COLUMNS = [
+      "linkedin profile",
+      "linkedin_profile",
+      "linkedin url",
+      "linkedin_url",
+      "linkedin",
+      "profile url",
+      "profile_url"
+    ];
+    NAME_COLUMNS = ["full name", "full_name", "name"];
+    COMPANY_COLUMNS = ["company name", "company_name", "company"];
   }
 });
 
@@ -13821,9 +14361,13 @@ async function handleFeedback(args) {
     });
     if (!response.ok) {
       const body = await response.text().catch(() => "unknown");
-      throw createGtmError("PROVIDER_REQUEST_FAILED", `Failed to submit feedback: ${response.status}`, {
-        details: { status: response.status, body }
-      });
+      throw createGtmError(
+        "PROVIDER_REQUEST_FAILED",
+        `Failed to submit feedback: ${response.status}`,
+        {
+          details: { status: response.status, body }
+        }
+      );
     }
     const data = await response.json();
     const created = data[0];
@@ -13836,7 +14380,10 @@ async function handleFeedback(args) {
   } catch (error) {
     if (error && typeof error === "object" && "error_code" in error) throw error;
     logError("feedback:submit", error instanceof Error ? error : new Error(String(error)));
-    throw createGtmError("PROVIDER_REQUEST_FAILED", "Failed to submit feedback. Please try again later.");
+    throw createGtmError(
+      "PROVIDER_REQUEST_FAILED",
+      "Failed to submit feedback. Please try again later."
+    );
   }
 }
 var VIEWER_URL2;
@@ -14249,6 +14796,9 @@ var init_validation = __esm({
         linkedin_url: z2.string().optional(),
         find_email: z2.boolean().optional(),
         profile: z2.string().optional(),
+        profiles: z2.array(z2.string()).optional(),
+        csv_file: z2.string().optional(),
+        concurrency: z2.number().int().min(1).max(20).optional(),
         company: z2.string().optional(),
         posted_within: z2.enum(["24h", "week", "month"]).optional(),
         post_url: z2.string().optional(),
@@ -14257,14 +14807,16 @@ var init_validation = __esm({
         sort: z2.enum(["relevance", "date"]).optional(),
         limit: z2.number().int().min(1).max(100).optional(),
         fields: z2.array(z2.string()).optional(),
-        detail: detailSchema
+        detail: detailSchema,
+        output: z2.enum(["file", "csv", "inline"]).optional(),
+        review: z2.boolean().optional()
       }).refine(
         (data) => {
           switch (data.type) {
             case "linkedin_profile":
               return !!(data.linkedin_url || data.url);
             case "linkedin_posts":
-              return !!data.profile;
+              return !!(data.profile || data.profiles?.length || data.csv_file);
             case "linkedin_engagement":
               return !!data.post_url;
             case "linkedin_search":
@@ -14525,7 +15077,7 @@ var init_server = __esm({
 });
 
 // src/cli-commands.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
 function registerCommands(program, exec2) {
   buildServeCommand(program);
   buildStatusCommand(program, exec2);
@@ -14654,11 +15206,11 @@ function parseContactsArg(value, writeError2) {
       writeError2("Failed to parse --contacts as JSON", { received: trimmed.slice(0, 200) });
     }
   }
-  if (!existsSync2(value)) {
+  if (!existsSync3(value)) {
     writeError2(`Contacts file not found: ${value}`);
   }
   try {
-    const content = readFileSync2(value, "utf-8");
+    const content = readFileSync3(value, "utf-8");
     const parsed = JSON.parse(content);
     return Array.isArray(parsed) ? parsed : [parsed];
   } catch (err) {