heyreach-cli 0.1.0

package/dist/mcp.js

@@ -0,0 +1,2359 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/core/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function loadConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) return {};
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+var CONFIG_DIR, CONFIG_FILE;
+var init_config = __esm({
+  "src/core/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    CONFIG_DIR = join(homedir(), ".heyreach");
+    CONFIG_FILE = join(CONFIG_DIR, "config.json");
+  }
+});
+
+// src/core/errors.ts
+function classifyHttpError(status, body) {
+  const parsed = safeParse(body);
+  const message = parsed?.message ?? parsed?.error ?? body;
+  if (status === 401 || status === 403) return new AuthError(message);
+  if (status === 404) return new NotFoundError(message);
+  if (status === 422) return new ValidationError(message);
+  if (status === 429) return new RateLimitError(message);
+  if (status >= 500) return new ServerError(message);
+  return new HeyReachError(message, "HTTP_ERROR", status);
+}
+function safeParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function formatError(error) {
+  if (error instanceof HeyReachError) {
+    return { error: error.message, code: error.code };
+  }
+  if (error instanceof Error) {
+    return { error: error.message, code: "UNKNOWN_ERROR" };
+  }
+  return { error: String(error), code: "UNKNOWN_ERROR" };
+}
+var HeyReachError, AuthError, NotFoundError, ValidationError, RateLimitError, ServerError;
+var init_errors = __esm({
+  "src/core/errors.ts"() {
+    "use strict";
+    init_esm_shims();
+    HeyReachError = class extends Error {
+      code;
+      statusCode;
+      constructor(message, code, statusCode) {
+        super(message);
+        this.name = "HeyReachError";
+        this.code = code;
+        this.statusCode = statusCode;
+      }
+    };
+    AuthError = class extends HeyReachError {
+      constructor(message = 'Authentication failed. Run "heyreach login" or set HEYREACH_API_KEY.') {
+        super(message, "AUTH_ERROR", 401);
+        this.name = "AuthError";
+      }
+    };
+    NotFoundError = class extends HeyReachError {
+      constructor(message = "Resource not found.") {
+        super(message, "NOT_FOUND", 404);
+        this.name = "NotFoundError";
+      }
+    };
+    ValidationError = class extends HeyReachError {
+      constructor(message = "Validation failed.") {
+        super(message, "VALIDATION_ERROR", 422);
+        this.name = "ValidationError";
+      }
+    };
+    RateLimitError = class extends HeyReachError {
+      retryAfter;
+      constructor(message = "Rate limit exceeded (300 req/min). Try again later.", retryAfter) {
+        super(message, "RATE_LIMIT", 429);
+        this.name = "RateLimitError";
+        this.retryAfter = retryAfter;
+      }
+    };
+    ServerError = class extends HeyReachError {
+      constructor(message = "Server error. Try again later.") {
+        super(message, "SERVER_ERROR", 500);
+        this.name = "ServerError";
+      }
+    };
+  }
+});
+
+// src/core/auth.ts
+function resolveAuth(opts) {
+  const config = loadConfig();
+  const apiKey = opts?.apiKey ?? process.env.HEYREACH_API_KEY ?? config.api_key;
+  if (!apiKey) {
+    throw new AuthError(
+      'No API key found. Run "heyreach login" or set HEYREACH_API_KEY.'
+    );
+  }
+  return { apiKey, baseUrl: BASE_URL };
+}
+var BASE_URL;
+var init_auth = __esm({
+  "src/core/auth.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_errors();
+    BASE_URL = "https://api.heyreach.io/api/public";
+  }
+});
+
+// src/core/client.ts
+function createClient(auth) {
+  async function request(opts) {
+    const url = buildUrl(auth.baseUrl, opts.path, opts.query);
+    const headers = {
+      "X-API-KEY": auth.apiKey,
+      Accept: "application/json"
+    };
+    let bodyStr;
+    if (opts.body && Object.keys(opts.body).length > 0) {
+      headers["Content-Type"] = "application/json";
+      bodyStr = JSON.stringify(opts.body);
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+        const res = await fetch(url, {
+          method: opts.method,
+          headers,
+          body: bodyStr,
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (res.ok) {
+          const text = await res.text();
+          if (!text) return { success: true };
+          try {
+            return JSON.parse(text);
+          } catch {
+            return { data: text };
+          }
+        }
+        const errorBody = await res.text();
+        if (res.status === 429 || res.status >= 500) {
+          lastError = classifyHttpError(res.status, errorBody);
+          if (attempt < MAX_RETRIES) {
+            const retryAfter = res.status === 429 ? parseRetryAfter(res.headers.get("Retry-After")) : void 0;
+            const backoff = retryAfter ?? INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+            await sleep(backoff);
+            continue;
+          }
+        }
+        throw classifyHttpError(res.status, errorBody);
+      } catch (err) {
+        if (err instanceof RateLimitError && attempt < MAX_RETRIES) {
+          lastError = err;
+          await sleep(INITIAL_BACKOFF_MS * Math.pow(2, attempt));
+          continue;
+        }
+        if (err instanceof Error && err.name === "AbortError") {
+          lastError = new Error(`Request timed out after ${DEFAULT_TIMEOUT_MS}ms`);
+          if (attempt < MAX_RETRIES) {
+            await sleep(INITIAL_BACKOFF_MS * Math.pow(2, attempt));
+            continue;
+          }
+        }
+        throw err;
+      }
+    }
+    throw lastError ?? new Error("Request failed after retries");
+  }
+  async function paginate(opts, maxPages = 10) {
+    const allItems = [];
+    let offset = 0;
+    const limit = 100;
+    for (let i = 0; i < maxPages; i++) {
+      const body = { ...opts.body, offset, limit };
+      const result = await request({ ...opts, body });
+      const items = result?.items;
+      if (items) {
+        allItems.push(...items);
+      } else {
+        return result;
+      }
+      const totalCount = result?.totalCount;
+      if (!totalCount || allItems.length >= totalCount) break;
+      offset += limit;
+    }
+    return { totalCount: allItems.length, items: allItems };
+  }
+  return { request, paginate };
+}
+function buildUrl(baseUrl, path2, query) {
+  const url = new URL(path2, baseUrl.endsWith("/") ? baseUrl : baseUrl + "/");
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0 && value !== null) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+function parseRetryAfter(header) {
+  if (!header) return void 0;
+  const seconds = parseInt(header, 10);
+  return isNaN(seconds) ? void 0 : seconds * 1e3;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var DEFAULT_TIMEOUT_MS, MAX_RETRIES, INITIAL_BACKOFF_MS;
+var init_client = __esm({
+  "src/core/client.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_errors();
+    DEFAULT_TIMEOUT_MS = 3e4;
+    MAX_RETRIES = 3;
+    INITIAL_BACKOFF_MS = 1e3;
+  }
+});
+
+// src/core/output.ts
+var init_output = __esm({
+  "src/core/output.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/campaigns/list.ts
+import { z } from "zod";
+var campaignsListCommand;
+var init_list = __esm({
+  "src/commands/campaigns/list.ts"() {
+    "use strict";
+    init_esm_shims();
+    campaignsListCommand = {
+      name: "campaigns_list",
+      group: "campaigns",
+      subcommand: "list",
+      description: "Get a paginated list of all campaigns. Up to 100 per request.",
+      examples: [
+        "heyreach campaigns list",
+        'heyreach campaigns list --keyword "outbound" --pretty',
+        "heyreach campaigns list --statuses IN_PROGRESS,PAUSED"
+      ],
+      inputSchema: z.object({
+        offset: z.coerce.number().default(0).describe("Pagination offset"),
+        limit: z.coerce.number().min(1).max(100).default(100).describe("Items per page (max 100)"),
+        keyword: z.string().optional().describe("Filter by campaign name"),
+        statuses: z.string().optional().describe("Comma-separated statuses: DRAFT,IN_PROGRESS,PAUSED,FINISHED,CANCELED,FAILED,STARTING,SCHEDULED"),
+        accountIds: z.string().optional().describe("Comma-separated LinkedIn account IDs")
+      }),
+      cliMappings: {
+        options: [
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page (max 100)" },
+          { field: "keyword", flags: "--keyword <text>", description: "Filter by campaign name" },
+          { field: "statuses", flags: "--statuses <list>", description: "Comma-separated statuses" },
+          { field: "accountIds", flags: "--account-ids <list>", description: "Comma-separated LinkedIn account IDs" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/campaign/GetAll" },
+      fieldMappings: { offset: "body", limit: "body", keyword: "body", statuses: "body", accountIds: "body" },
+      handler: async (input, client) => {
+        const body = {
+          offset: input.offset,
+          limit: input.limit
+        };
+        if (input.keyword) body.keyword = input.keyword;
+        if (input.statuses) body.statuses = input.statuses.split(",").map((s) => s.trim());
+        if (input.accountIds) body.accountIds = input.accountIds.split(",").map((s) => Number(s.trim()));
+        return client.request({ method: "POST", path: "/campaign/GetAll", body });
+      }
+    };
+  }
+});
+
+// src/core/handler.ts
+async function executeCommand(cmdDef, input, client) {
+  let path2 = cmdDef.endpoint.path;
+  const query = {};
+  const body = {};
+  for (const [field, location] of Object.entries(cmdDef.fieldMappings)) {
+    const value = input[field];
+    if (value === void 0 || value === null) continue;
+    switch (location) {
+      case "path":
+        path2 = path2.replace(`{${field}}`, encodeURIComponent(String(value)));
+        break;
+      case "query":
+        query[field] = value;
+        break;
+      case "body":
+        body[field] = value;
+        break;
+    }
+  }
+  return client.request({
+    method: cmdDef.endpoint.method,
+    path: path2,
+    query: Object.keys(query).length > 0 ? query : void 0,
+    body: Object.keys(body).length > 0 ? body : void 0
+  });
+}
+var init_handler = __esm({
+  "src/core/handler.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/campaigns/get.ts
+import { z as z2 } from "zod";
+var campaignsGetCommand;
+var init_get = __esm({
+  "src/commands/campaigns/get.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    campaignsGetCommand = {
+      name: "campaigns_get",
+      group: "campaigns",
+      subcommand: "get",
+      description: "Get a campaign by ID.",
+      examples: ["heyreach campaigns get --campaign-id 12345 --pretty"],
+      inputSchema: z2.object({
+        campaignId: z2.coerce.number().describe("Campaign ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "campaignId", flags: "--campaign-id <id>", description: "Campaign ID" }
+        ]
+      },
+      endpoint: { method: "GET", path: "/campaign/GetById" },
+      fieldMappings: { campaignId: "query" },
+      handler: (input, client) => executeCommand(campaignsGetCommand, input, client)
+    };
+  }
+});
+
+// src/commands/campaigns/resume.ts
+import { z as z3 } from "zod";
+var campaignsResumeCommand;
+var init_resume = __esm({
+  "src/commands/campaigns/resume.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    campaignsResumeCommand = {
+      name: "campaigns_resume",
+      group: "campaigns",
+      subcommand: "resume",
+      description: "Resume a paused campaign.",
+      examples: ["heyreach campaigns resume --campaign-id 12345"],
+      inputSchema: z3.object({
+        campaignId: z3.coerce.number().describe("Campaign ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "campaignId", flags: "--campaign-id <id>", description: "Campaign ID" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/campaign/Resume" },
+      fieldMappings: { campaignId: "query" },
+      handler: (input, client) => executeCommand(campaignsResumeCommand, input, client)
+    };
+  }
+});
+
+// src/commands/campaigns/pause.ts
+import { z as z4 } from "zod";
+var campaignsPauseCommand;
+var init_pause = __esm({
+  "src/commands/campaigns/pause.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    campaignsPauseCommand = {
+      name: "campaigns_pause",
+      group: "campaigns",
+      subcommand: "pause",
+      description: "Pause a running campaign.",
+      examples: ["heyreach campaigns pause --campaign-id 12345"],
+      inputSchema: z4.object({
+        campaignId: z4.coerce.number().describe("Campaign ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "campaignId", flags: "--campaign-id <id>", description: "Campaign ID" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/campaign/Pause" },
+      fieldMappings: { campaignId: "query" },
+      handler: (input, client) => executeCommand(campaignsPauseCommand, input, client)
+    };
+  }
+});
+
+// src/commands/campaigns/add-leads.ts
+import { z as z5 } from "zod";
+var campaignsAddLeadsCommand;
+var init_add_leads = __esm({
+  "src/commands/campaigns/add-leads.ts"() {
+    "use strict";
+    init_esm_shims();
+    campaignsAddLeadsCommand = {
+      name: "campaigns_add_leads",
+      group: "campaigns",
+      subcommand: "add-leads",
+      description: "Add leads to a campaign (V2 \u2014 returns detailed counts). Up to 100 leads per request. Accepts JSON array via --leads-json.",
+      examples: [
+        `heyreach campaigns add-leads --campaign-id 123 --leads-json '[{"lead":{"firstName":"Jane","lastName":"Doe","profileUrl":"https://linkedin.com/in/janedoe"}}]'`
+      ],
+      inputSchema: z5.object({
+        campaignId: z5.coerce.number().describe("Campaign ID"),
+        leadsJson: z5.string().describe("JSON array of accountLeadPairs"),
+        resumeFinishedCampaign: z5.coerce.boolean().optional().describe("Resume if campaign finished"),
+        resumePausedCampaign: z5.coerce.boolean().optional().describe("Resume if campaign paused")
+      }),
+      cliMappings: {
+        options: [
+          { field: "campaignId", flags: "--campaign-id <id>", description: "Campaign ID" },
+          { field: "leadsJson", flags: "--leads-json <json>", description: "JSON array of accountLeadPairs" },
+          { field: "resumeFinishedCampaign", flags: "--resume-finished", description: "Resume if campaign finished" },
+          { field: "resumePausedCampaign", flags: "--resume-paused", description: "Resume if campaign paused" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/campaign/AddLeadsToCampaignV2" },
+      fieldMappings: { campaignId: "body", leadsJson: "body", resumeFinishedCampaign: "body", resumePausedCampaign: "body" },
+      handler: async (input, client) => {
+        const accountLeadPairs = JSON.parse(input.leadsJson);
+        const body = {
+          campaignId: input.campaignId,
+          accountLeadPairs
+        };
+        if (input.resumeFinishedCampaign !== void 0) body.resumeFinishedCampaign = input.resumeFinishedCampaign;
+        if (input.resumePausedCampaign !== void 0) body.resumePausedCampaign = input.resumePausedCampaign;
+        return client.request({ method: "POST", path: "/campaign/AddLeadsToCampaignV2", body });
+      }
+    };
+  }
+});
+
+// src/commands/campaigns/stop-lead.ts
+import { z as z6 } from "zod";
+var campaignsStopLeadCommand;
+var init_stop_lead = __esm({
+  "src/commands/campaigns/stop-lead.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    campaignsStopLeadCommand = {
+      name: "campaigns_stop_lead",
+      group: "campaigns",
+      subcommand: "stop-lead",
+      description: "Stop the progression of a lead in a campaign.",
+      examples: [
+        'heyreach campaigns stop-lead --campaign-id 123 --lead-url "https://linkedin.com/in/janedoe"',
+        'heyreach campaigns stop-lead --campaign-id 123 --lead-member-id "ABC123"'
+      ],
+      inputSchema: z6.object({
+        campaignId: z6.coerce.number().describe("Campaign ID"),
+        leadMemberId: z6.string().optional().describe("LinkedIn member ID"),
+        leadUrl: z6.string().optional().describe("LinkedIn profile URL")
+      }),
+      cliMappings: {
+        options: [
+          { field: "campaignId", flags: "--campaign-id <id>", description: "Campaign ID" },
+          { field: "leadMemberId", flags: "--lead-member-id <id>", description: "LinkedIn member ID" },
+          { field: "leadUrl", flags: "--lead-url <url>", description: "LinkedIn profile URL" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/campaign/StopLeadInCampaign" },
+      fieldMappings: { campaignId: "body", leadMemberId: "body", leadUrl: "body" },
+      handler: (input, client) => executeCommand(campaignsStopLeadCommand, input, client)
+    };
+  }
+});
+
+// src/commands/campaigns/get-leads.ts
+import { z as z7 } from "zod";
+var campaignsGetLeadsCommand;
+var init_get_leads = __esm({
+  "src/commands/campaigns/get-leads.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    campaignsGetLeadsCommand = {
+      name: "campaigns_get_leads",
+      group: "campaigns",
+      subcommand: "get-leads",
+      description: "Get leads from a campaign (Lead Analytics). Shows pending leads about to start executing.",
+      examples: ["heyreach campaigns get-leads --campaign-id 123 --pretty"],
+      inputSchema: z7.object({
+        campaignId: z7.coerce.number().describe("Campaign ID"),
+        offset: z7.coerce.number().default(0).describe("Pagination offset"),
+        limit: z7.coerce.number().min(1).max(100).default(100).describe("Items per page"),
+        timeFrom: z7.string().optional().describe("Start time (ISO 8601)"),
+        timeTo: z7.string().optional().describe("End time (ISO 8601)"),
+        timeFilter: z7.string().optional().describe("Time filter: CreationTime|Everywhere|LastActionTakenTime|FailedTime|LastActionTakenOrFailedTime")
+      }),
+      cliMappings: {
+        options: [
+          { field: "campaignId", flags: "--campaign-id <id>", description: "Campaign ID" },
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" },
+          { field: "timeFrom", flags: "--time-from <iso>", description: "Start time (ISO 8601)" },
+          { field: "timeTo", flags: "--time-to <iso>", description: "End time (ISO 8601)" },
+          { field: "timeFilter", flags: "--time-filter <type>", description: "Time filter type" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/campaign/GetLeadsFromCampaign" },
+      fieldMappings: { campaignId: "body", offset: "body", limit: "body", timeFrom: "body", timeTo: "body", timeFilter: "body" },
+      handler: (input, client) => executeCommand(campaignsGetLeadsCommand, input, client)
+    };
+  }
+});
+
+// src/commands/campaigns/get-for-lead.ts
+import { z as z8 } from "zod";
+var campaignsGetForLeadCommand;
+var init_get_for_lead = __esm({
+  "src/commands/campaigns/get-for-lead.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    campaignsGetForLeadCommand = {
+      name: "campaigns_get_for_lead",
+      group: "campaigns",
+      subcommand: "get-for-lead",
+      description: "Get campaigns where a specific lead is enrolled.",
+      examples: [
+        'heyreach campaigns get-for-lead --profile-url "https://linkedin.com/in/janedoe" --pretty',
+        'heyreach campaigns get-for-lead --email "jane@example.com"'
+      ],
+      inputSchema: z8.object({
+        offset: z8.coerce.number().default(0).describe("Pagination offset"),
+        limit: z8.coerce.number().min(1).max(100).default(100).describe("Items per page"),
+        email: z8.string().optional().describe("Lead email address"),
+        linkedinId: z8.string().optional().describe("Lead LinkedIn ID"),
+        profileUrl: z8.string().optional().describe("Lead LinkedIn profile URL")
+      }),
+      cliMappings: {
+        options: [
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" },
+          { field: "email", flags: "--email <email>", description: "Lead email address" },
+          { field: "linkedinId", flags: "--linkedin-id <id>", description: "Lead LinkedIn ID" },
+          { field: "profileUrl", flags: "--profile-url <url>", description: "Lead LinkedIn profile URL" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/campaign/GetCampaignsForLead" },
+      fieldMappings: { offset: "body", limit: "body", email: "body", linkedinId: "body", profileUrl: "body" },
+      handler: (input, client) => executeCommand(campaignsGetForLeadCommand, input, client)
+    };
+  }
+});
+
+// src/commands/campaigns/index.ts
+var campaignCommands;
+var init_campaigns = __esm({
+  "src/commands/campaigns/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_list();
+    init_get();
+    init_resume();
+    init_pause();
+    init_add_leads();
+    init_stop_lead();
+    init_get_leads();
+    init_get_for_lead();
+    campaignCommands = [
+      campaignsListCommand,
+      campaignsGetCommand,
+      campaignsResumeCommand,
+      campaignsPauseCommand,
+      campaignsAddLeadsCommand,
+      campaignsStopLeadCommand,
+      campaignsGetLeadsCommand,
+      campaignsGetForLeadCommand
+    ];
+  }
+});
+
+// src/commands/inbox/list.ts
+import { z as z9 } from "zod";
+var inboxListCommand;
+var init_list2 = __esm({
+  "src/commands/inbox/list.ts"() {
+    "use strict";
+    init_esm_shims();
+    inboxListCommand = {
+      name: "inbox_list",
+      group: "inbox",
+      subcommand: "list",
+      description: "Get a paginated list of LinkedIn conversations. Up to 100 per request.",
+      examples: [
+        "heyreach inbox list --pretty",
+        'heyreach inbox list --search "product demo" --seen false'
+      ],
+      inputSchema: z9.object({
+        offset: z9.coerce.number().default(0).describe("Pagination offset"),
+        limit: z9.coerce.number().min(1).max(100).default(100).describe("Items per page"),
+        linkedInAccountIds: z9.string().optional().describe("Comma-separated LinkedIn account IDs"),
+        campaignIds: z9.string().optional().describe("Comma-separated campaign IDs"),
+        searchString: z9.string().optional().describe("Search conversations"),
+        leadLinkedInId: z9.string().optional().describe("Filter by lead LinkedIn ID"),
+        leadProfileUrl: z9.string().optional().describe("Filter by lead profile URL"),
+        tags: z9.string().optional().describe("Comma-separated lead tags"),
+        seen: z9.string().optional().describe("Filter by seen status: true/false")
+      }),
+      cliMappings: {
+        options: [
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" },
+          { field: "linkedInAccountIds", flags: "--account-ids <list>", description: "Comma-separated LinkedIn account IDs" },
+          { field: "campaignIds", flags: "--campaign-ids <list>", description: "Comma-separated campaign IDs" },
+          { field: "searchString", flags: "--search <text>", description: "Search conversations" },
+          { field: "leadLinkedInId", flags: "--lead-linkedin-id <id>", description: "Filter by lead LinkedIn ID" },
+          { field: "leadProfileUrl", flags: "--lead-profile-url <url>", description: "Filter by lead profile URL" },
+          { field: "tags", flags: "--tags <list>", description: "Comma-separated lead tags" },
+          { field: "seen", flags: "--seen <bool>", description: "Filter by seen status" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/inbox/GetConversationsV2" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const filters = {};
+        if (input.linkedInAccountIds) filters.linkedInAccountIds = input.linkedInAccountIds.split(",").map((s) => Number(s.trim()));
+        if (input.campaignIds) filters.campaignIds = input.campaignIds.split(",").map((s) => Number(s.trim()));
+        if (input.searchString) filters.searchString = input.searchString;
+        if (input.leadLinkedInId) filters.leadLinkedInId = input.leadLinkedInId;
+        if (input.leadProfileUrl) filters.leadProfileUrl = input.leadProfileUrl;
+        if (input.tags) filters.tags = input.tags.split(",").map((s) => s.trim());
+        if (input.seen !== void 0) filters.seen = input.seen === "true";
+        return client.request({
+          method: "POST",
+          path: "/inbox/GetConversationsV2",
+          body: { offset: input.offset, limit: input.limit, filters }
+        });
+      }
+    };
+  }
+});
+
+// src/commands/inbox/get.ts
+import { z as z10 } from "zod";
+var inboxGetCommand;
+var init_get2 = __esm({
+  "src/commands/inbox/get.ts"() {
+    "use strict";
+    init_esm_shims();
+    inboxGetCommand = {
+      name: "inbox_get",
+      group: "inbox",
+      subcommand: "get",
+      description: "Get a LinkedIn conversation with messages by account ID and conversation ID.",
+      examples: ['heyreach inbox get --account-id 123 --conversation-id "abc-def"'],
+      inputSchema: z10.object({
+        accountId: z10.coerce.number().describe("LinkedIn account ID"),
+        conversationId: z10.string().describe("Conversation ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "accountId", flags: "--account-id <id>", description: "LinkedIn account ID" },
+          { field: "conversationId", flags: "--conversation-id <id>", description: "Conversation ID" }
+        ]
+      },
+      endpoint: { method: "GET", path: "/inbox/GetChatroom/{accountId}/{conversationId}" },
+      fieldMappings: { accountId: "path", conversationId: "path" },
+      handler: async (input, client) => {
+        return client.request({
+          method: "GET",
+          path: `/inbox/GetChatroom/${encodeURIComponent(String(input.accountId))}/${encodeURIComponent(String(input.conversationId))}`
+        });
+      }
+    };
+  }
+});
+
+// src/commands/inbox/send.ts
+import { z as z11 } from "zod";
+var inboxSendCommand;
+var init_send = __esm({
+  "src/commands/inbox/send.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    inboxSendCommand = {
+      name: "inbox_send",
+      group: "inbox",
+      subcommand: "send",
+      description: "Send a message to a LinkedIn conversation.",
+      examples: ['heyreach inbox send --conversation-id "abc" --account-id 123 --message "Hello!"'],
+      inputSchema: z11.object({
+        message: z11.string().describe("Message text"),
+        conversationId: z11.string().describe("Conversation ID"),
+        linkedInAccountId: z11.coerce.number().describe("LinkedIn account ID"),
+        subject: z11.string().optional().describe("Message subject")
+      }),
+      cliMappings: {
+        options: [
+          { field: "message", flags: "--message <text>", description: "Message text" },
+          { field: "conversationId", flags: "--conversation-id <id>", description: "Conversation ID" },
+          { field: "linkedInAccountId", flags: "--account-id <id>", description: "LinkedIn account ID" },
+          { field: "subject", flags: "--subject <text>", description: "Message subject" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/inbox/SendMessage" },
+      fieldMappings: { message: "body", conversationId: "body", linkedInAccountId: "body", subject: "body" },
+      handler: (input, client) => executeCommand(inboxSendCommand, input, client)
+    };
+  }
+});
+
+// src/commands/inbox/set-seen.ts
+import { z as z12 } from "zod";
+var inboxSetSeenCommand;
+var init_set_seen = __esm({
+  "src/commands/inbox/set-seen.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    inboxSetSeenCommand = {
+      name: "inbox_set_seen",
+      group: "inbox",
+      subcommand: "set-seen",
+      description: "Mark a conversation as seen or unseen.",
+      examples: ['heyreach inbox set-seen --conversation-id "abc" --account-id 123 --seen true'],
+      inputSchema: z12.object({
+        conversationId: z12.string().describe("Conversation ID"),
+        linkedInAccountId: z12.coerce.number().describe("LinkedIn account ID"),
+        seen: z12.coerce.boolean().describe("Mark as seen (true) or unseen (false)")
+      }),
+      cliMappings: {
+        options: [
+          { field: "conversationId", flags: "--conversation-id <id>", description: "Conversation ID" },
+          { field: "linkedInAccountId", flags: "--account-id <id>", description: "LinkedIn account ID" },
+          { field: "seen", flags: "--seen <bool>", description: "Seen status (true/false)" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/inbox/SetSeenStatus" },
+      fieldMappings: { conversationId: "body", linkedInAccountId: "body", seen: "body" },
+      handler: (input, client) => executeCommand(inboxSetSeenCommand, input, client)
+    };
+  }
+});
+
+// src/commands/inbox/index.ts
+var inboxCommands;
+var init_inbox = __esm({
+  "src/commands/inbox/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_list2();
+    init_get2();
+    init_send();
+    init_set_seen();
+    inboxCommands = [
+      inboxListCommand,
+      inboxGetCommand,
+      inboxSendCommand,
+      inboxSetSeenCommand
+    ];
+  }
+});
+
+// src/commands/accounts/list.ts
+import { z as z13 } from "zod";
+var accountsListCommand;
+var init_list3 = __esm({
+  "src/commands/accounts/list.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    accountsListCommand = {
+      name: "accounts_list",
+      group: "accounts",
+      subcommand: "list",
+      description: "Get a paginated list of all LinkedIn accounts. Up to 100 per request.",
+      examples: ["heyreach accounts list --pretty", 'heyreach accounts list --keyword "john"'],
+      inputSchema: z13.object({
+        offset: z13.coerce.number().default(0).describe("Pagination offset"),
+        limit: z13.coerce.number().min(1).max(100).default(100).describe("Items per page"),
+        keyword: z13.string().optional().describe("Search by account name")
+      }),
+      cliMappings: {
+        options: [
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" },
+          { field: "keyword", flags: "--keyword <text>", description: "Search by account name" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/li_account/GetAll" },
+      fieldMappings: { offset: "body", limit: "body", keyword: "body" },
+      handler: (input, client) => executeCommand(accountsListCommand, input, client)
+    };
+  }
+});
+
+// src/commands/accounts/get.ts
+import { z as z14 } from "zod";
+var accountsGetCommand;
+var init_get3 = __esm({
+  "src/commands/accounts/get.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    accountsGetCommand = {
+      name: "accounts_get",
+      group: "accounts",
+      subcommand: "get",
+      description: "Get a LinkedIn account by ID.",
+      examples: ["heyreach accounts get --account-id 123 --pretty"],
+      inputSchema: z14.object({
+        accountId: z14.coerce.number().describe("LinkedIn account ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "accountId", flags: "--account-id <id>", description: "LinkedIn account ID" }
+        ]
+      },
+      endpoint: { method: "GET", path: "/li_account/GetById" },
+      fieldMappings: { accountId: "query" },
+      handler: (input, client) => executeCommand(accountsGetCommand, input, client)
+    };
+  }
+});
+
+// src/commands/accounts/index.ts
+var accountCommands;
+var init_accounts = __esm({
+  "src/commands/accounts/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_list3();
+    init_get3();
+    accountCommands = [
+      accountsListCommand,
+      accountsGetCommand
+    ];
+  }
+});
+
+// src/commands/lists/get.ts
+import { z as z15 } from "zod";
+var listsGetCommand;
+var init_get4 = __esm({
+  "src/commands/lists/get.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    listsGetCommand = {
+      name: "lists_get",
+      group: "lists",
+      subcommand: "get",
+      description: "Get a lead or company list by ID.",
+      examples: ["heyreach lists get --list-id 456 --pretty"],
+      inputSchema: z15.object({
+        listId: z15.coerce.number().describe("List ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "listId", flags: "--list-id <id>", description: "List ID" }
+        ]
+      },
+      endpoint: { method: "GET", path: "/list/GetById" },
+      fieldMappings: { listId: "query" },
+      handler: (input, client) => executeCommand(listsGetCommand, input, client)
+    };
+  }
+});
+
+// src/commands/lists/list.ts
+import { z as z16 } from "zod";
+var listsListCommand;
+var init_list4 = __esm({
+  "src/commands/lists/list.ts"() {
+    "use strict";
+    init_esm_shims();
+    listsListCommand = {
+      name: "lists_list",
+      group: "lists",
+      subcommand: "list",
+      description: "Get a paginated list of all lead and company lists. Up to 100 per request.",
+      examples: [
+        "heyreach lists list --pretty",
+        "heyreach lists list --list-type USER_LIST"
+      ],
+      inputSchema: z16.object({
+        offset: z16.coerce.number().default(0).describe("Pagination offset"),
+        limit: z16.coerce.number().min(1).max(100).default(100).describe("Items per page"),
+        keyword: z16.string().optional().describe("Search by list name"),
+        listType: z16.string().optional().describe("Filter by type: USER_LIST or COMPANY_LIST"),
+        campaignIds: z16.string().optional().describe("Comma-separated campaign IDs")
+      }),
+      cliMappings: {
+        options: [
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" },
+          { field: "keyword", flags: "--keyword <text>", description: "Search by list name" },
+          { field: "listType", flags: "--list-type <type>", description: "USER_LIST or COMPANY_LIST" },
+          { field: "campaignIds", flags: "--campaign-ids <list>", description: "Comma-separated campaign IDs" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/list/GetAll" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const body = { offset: input.offset, limit: input.limit };
+        if (input.keyword) body.keyword = input.keyword;
+        if (input.listType) body.listType = input.listType;
+        if (input.campaignIds) body.campaignIds = input.campaignIds.split(",").map((s) => Number(s.trim()));
+        return client.request({ method: "POST", path: "/list/GetAll", body });
+      }
+    };
+  }
+});
+
+// src/commands/lists/create.ts
+import { z as z17 } from "zod";
+var listsCreateCommand;
+var init_create = __esm({
+  "src/commands/lists/create.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    listsCreateCommand = {
+      name: "lists_create",
+      group: "lists",
+      subcommand: "create",
+      description: "Create an empty lead or company list.",
+      examples: [
+        'heyreach lists create --name "Q1 Prospects"',
+        'heyreach lists create --name "Target Companies" --type COMPANY_LIST'
+      ],
+      inputSchema: z17.object({
+        name: z17.string().describe("List name"),
+        type: z17.string().optional().describe("List type: USER_LIST (default) or COMPANY_LIST")
+      }),
+      cliMappings: {
+        options: [
+          { field: "name", flags: "--name <name>", description: "List name" },
+          { field: "type", flags: "--type <type>", description: "USER_LIST or COMPANY_LIST" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/list/CreateEmptyList" },
+      fieldMappings: { name: "body", type: "body" },
+      handler: (input, client) => executeCommand(listsCreateCommand, input, client)
+    };
+  }
+});
+
+// src/commands/lists/get-leads.ts
+import { z as z18 } from "zod";
+var listsGetLeadsCommand;
+var init_get_leads2 = __esm({
+  "src/commands/lists/get-leads.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    listsGetLeadsCommand = {
+      name: "lists_get_leads",
+      group: "lists",
+      subcommand: "get-leads",
+      description: "Get a paginated list of leads from a lead list. Up to 1000 per request.",
+      examples: ["heyreach lists get-leads --list-id 456 --pretty"],
+      inputSchema: z18.object({
+        listId: z18.coerce.number().describe("List ID"),
+        offset: z18.coerce.number().default(0).describe("Pagination offset"),
+        limit: z18.coerce.number().min(1).max(1e3).default(100).describe("Items per page (max 1000)"),
+        keyword: z18.string().optional().describe("Search leads"),
+        leadProfileUrl: z18.string().optional().describe("Filter by profile URL"),
+        leadLinkedInId: z18.string().optional().describe("Filter by LinkedIn ID"),
+        createdFrom: z18.string().optional().describe("Created from (ISO 8601)"),
+        createdTo: z18.string().optional().describe("Created to (ISO 8601)")
+      }),
+      cliMappings: {
+        options: [
+          { field: "listId", flags: "--list-id <id>", description: "List ID" },
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" },
+          { field: "keyword", flags: "--keyword <text>", description: "Search leads" },
+          { field: "leadProfileUrl", flags: "--profile-url <url>", description: "Filter by profile URL" },
+          { field: "leadLinkedInId", flags: "--linkedin-id <id>", description: "Filter by LinkedIn ID" },
+          { field: "createdFrom", flags: "--created-from <iso>", description: "Created from (ISO 8601)" },
+          { field: "createdTo", flags: "--created-to <iso>", description: "Created to (ISO 8601)" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/list/GetLeadsFromList" },
+      fieldMappings: { listId: "body", offset: "body", limit: "body", keyword: "body", leadProfileUrl: "body", leadLinkedInId: "body", createdFrom: "body", createdTo: "body" },
+      handler: (input, client) => executeCommand(listsGetLeadsCommand, input, client)
+    };
+  }
+});
+
+// src/commands/lists/add-leads.ts
+import { z as z19 } from "zod";
+var listsAddLeadsCommand;
+var init_add_leads2 = __esm({
+  "src/commands/lists/add-leads.ts"() {
+    "use strict";
+    init_esm_shims();
+    listsAddLeadsCommand = {
+      name: "lists_add_leads",
+      group: "lists",
+      subcommand: "add-leads",
+      description: "Add leads to a lead list (V2 \u2014 returns detailed counts). Up to 100 per request. Accepts JSON array via --leads-json.",
+      examples: [
+        `heyreach lists add-leads --list-id 456 --leads-json '[{"firstName":"Jane","lastName":"Doe","profileUrl":"https://linkedin.com/in/janedoe"}]'`
+      ],
+      inputSchema: z19.object({
+        listId: z19.coerce.number().describe("List ID"),
+        leadsJson: z19.string().describe("JSON array of lead objects")
+      }),
+      cliMappings: {
+        options: [
+          { field: "listId", flags: "--list-id <id>", description: "List ID" },
+          { field: "leadsJson", flags: "--leads-json <json>", description: "JSON array of lead objects" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/list/AddLeadsToListV2" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const leads = JSON.parse(input.leadsJson);
+        return client.request({
+          method: "POST",
+          path: "/list/AddLeadsToListV2",
+          body: { listId: input.listId, leads }
+        });
+      }
+    };
+  }
+});
+
+// src/commands/lists/delete-leads.ts
+import { z as z20 } from "zod";
+var listsDeleteLeadsCommand;
+var init_delete_leads = __esm({
+  "src/commands/lists/delete-leads.ts"() {
+    "use strict";
+    init_esm_shims();
+    listsDeleteLeadsCommand = {
+      name: "lists_delete_leads",
+      group: "lists",
+      subcommand: "delete-leads",
+      description: "Delete leads from a list by LinkedIn member IDs.",
+      examples: ['heyreach lists delete-leads --list-id 456 --member-ids "id1,id2,id3"'],
+      inputSchema: z20.object({
+        listId: z20.coerce.number().describe("List ID"),
+        memberIds: z20.string().describe("Comma-separated LinkedIn member IDs")
+      }),
+      cliMappings: {
+        options: [
+          { field: "listId", flags: "--list-id <id>", description: "List ID" },
+          { field: "memberIds", flags: "--member-ids <list>", description: "Comma-separated LinkedIn member IDs" }
+        ]
+      },
+      endpoint: { method: "DELETE", path: "/list/DeleteLeadsFromList" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const leadMemberIds = input.memberIds.split(",").map((s) => s.trim());
+        return client.request({
+          method: "DELETE",
+          path: "/list/DeleteLeadsFromList",
+          body: { listId: input.listId, leadMemberIds }
+        });
+      }
+    };
+  }
+});
+
+// src/commands/lists/delete-leads-by-url.ts
+import { z as z21 } from "zod";
+var listsDeleteLeadsByUrlCommand;
+var init_delete_leads_by_url = __esm({
+  "src/commands/lists/delete-leads-by-url.ts"() {
+    "use strict";
+    init_esm_shims();
+    listsDeleteLeadsByUrlCommand = {
+      name: "lists_delete_leads_by_url",
+      group: "lists",
+      subcommand: "delete-leads-by-url",
+      description: "Delete leads from a list by LinkedIn profile URLs.",
+      examples: ['heyreach lists delete-leads-by-url --list-id 456 --urls "https://linkedin.com/in/jane,https://linkedin.com/in/john"'],
+      inputSchema: z21.object({
+        listId: z21.coerce.number().describe("List ID"),
+        urls: z21.string().describe("Comma-separated LinkedIn profile URLs")
+      }),
+      cliMappings: {
+        options: [
+          { field: "listId", flags: "--list-id <id>", description: "List ID" },
+          { field: "urls", flags: "--urls <list>", description: "Comma-separated LinkedIn profile URLs" }
+        ]
+      },
+      endpoint: { method: "DELETE", path: "/list/DeleteLeadsFromListByProfileUrl" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const profileUrls = input.urls.split(",").map((s) => s.trim());
+        return client.request({
+          method: "DELETE",
+          path: "/list/DeleteLeadsFromListByProfileUrl",
+          body: { listId: input.listId, profileUrls }
+        });
+      }
+    };
+  }
+});
+
+// src/commands/lists/get-companies.ts
+import { z as z22 } from "zod";
+var listsGetCompaniesCommand;
+var init_get_companies = __esm({
+  "src/commands/lists/get-companies.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    listsGetCompaniesCommand = {
+      name: "lists_get_companies",
+      group: "lists",
+      subcommand: "get-companies",
+      description: "Get a paginated list of companies from a company list. Up to 1000 per request.",
+      examples: ["heyreach lists get-companies --list-id 789 --pretty"],
+      inputSchema: z22.object({
+        listId: z22.coerce.number().describe("List ID"),
+        offset: z22.coerce.number().default(0).describe("Pagination offset"),
+        limit: z22.coerce.number().min(1).max(1e3).default(100).describe("Items per page (max 1000)"),
+        keyword: z22.string().optional().describe("Search companies")
+      }),
+      cliMappings: {
+        options: [
+          { field: "listId", flags: "--list-id <id>", description: "List ID" },
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" },
+          { field: "keyword", flags: "--keyword <text>", description: "Search companies" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/list/GetCompaniesFromList" },
+      fieldMappings: { listId: "body", offset: "body", limit: "body", keyword: "body" },
+      handler: (input, client) => executeCommand(listsGetCompaniesCommand, input, client)
+    };
+  }
+});
+
+// src/commands/lists/get-for-lead.ts
+import { z as z23 } from "zod";
+var listsGetForLeadCommand;
+var init_get_for_lead2 = __esm({
+  "src/commands/lists/get-for-lead.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    listsGetForLeadCommand = {
+      name: "lists_get_for_lead",
+      group: "lists",
+      subcommand: "get-for-lead",
+      description: "Get lists associated with a specific lead.",
+      examples: ['heyreach lists get-for-lead --profile-url "https://linkedin.com/in/janedoe"'],
+      inputSchema: z23.object({
+        offset: z23.coerce.number().default(0).describe("Pagination offset"),
+        limit: z23.coerce.number().min(1).max(100).default(100).describe("Items per page"),
+        email: z23.string().optional().describe("Lead email"),
+        linkedinId: z23.string().optional().describe("Lead LinkedIn ID"),
+        profileUrl: z23.string().optional().describe("Lead LinkedIn profile URL")
+      }),
+      cliMappings: {
+        options: [
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" },
+          { field: "email", flags: "--email <email>", description: "Lead email" },
+          { field: "linkedinId", flags: "--linkedin-id <id>", description: "Lead LinkedIn ID" },
+          { field: "profileUrl", flags: "--profile-url <url>", description: "Lead profile URL" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/list/GetListsForLead" },
+      fieldMappings: { offset: "body", limit: "body", email: "body", linkedinId: "body", profileUrl: "body" },
+      handler: (input, client) => executeCommand(listsGetForLeadCommand, input, client)
+    };
+  }
+});
+
+// src/commands/lists/index.ts
+var listCommands;
+var init_lists = __esm({
+  "src/commands/lists/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_get4();
+    init_list4();
+    init_create();
+    init_get_leads2();
+    init_add_leads2();
+    init_delete_leads();
+    init_delete_leads_by_url();
+    init_get_companies();
+    init_get_for_lead2();
+    listCommands = [
+      listsGetCommand,
+      listsListCommand,
+      listsCreateCommand,
+      listsGetLeadsCommand,
+      listsAddLeadsCommand,
+      listsDeleteLeadsCommand,
+      listsDeleteLeadsByUrlCommand,
+      listsGetCompaniesCommand,
+      listsGetForLeadCommand
+    ];
+  }
+});
+
+// src/commands/stats/overview.ts
+import { z as z24 } from "zod";
+var statsOverviewCommand;
+var init_overview = __esm({
+  "src/commands/stats/overview.ts"() {
+    "use strict";
+    init_esm_shims();
+    statsOverviewCommand = {
+      name: "stats_overview",
+      group: "stats",
+      subcommand: "overview",
+      description: "Get overall stats with day-by-day breakdown for specified date range.",
+      examples: [
+        "heyreach stats overview --start-date 2025-01-01 --end-date 2025-01-31 --pretty",
+        'heyreach stats overview --start-date 2025-01-01 --end-date 2025-01-31 --campaign-ids "1,2,3"'
+      ],
+      inputSchema: z24.object({
+        startDate: z24.string().describe("Start date (ISO 8601)"),
+        endDate: z24.string().describe("End date (ISO 8601)"),
+        accountIds: z24.string().optional().describe("Comma-separated LinkedIn account IDs (empty = all)"),
+        campaignIds: z24.string().optional().describe("Comma-separated campaign IDs (empty = all)")
+      }),
+      cliMappings: {
+        options: [
+          { field: "startDate", flags: "--start-date <iso>", description: "Start date (ISO 8601)" },
+          { field: "endDate", flags: "--end-date <iso>", description: "End date (ISO 8601)" },
+          { field: "accountIds", flags: "--account-ids <list>", description: "Comma-separated LinkedIn account IDs" },
+          { field: "campaignIds", flags: "--campaign-ids <list>", description: "Comma-separated campaign IDs" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/stats/GetOverallStats" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const body = {
+          startDate: input.startDate,
+          endDate: input.endDate
+        };
+        if (input.accountIds) body.accountIds = input.accountIds.split(",").map((s) => Number(s.trim()));
+        if (input.campaignIds) body.campaignIds = input.campaignIds.split(",").map((s) => Number(s.trim()));
+        return client.request({ method: "POST", path: "/stats/GetOverallStats", body });
+      }
+    };
+  }
+});
+
+// src/commands/stats/index.ts
+var statsCommands;
+var init_stats = __esm({
+  "src/commands/stats/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_overview();
+    statsCommands = [statsOverviewCommand];
+  }
+});
+
+// src/commands/leads/get.ts
+import { z as z25 } from "zod";
+var leadsGetCommand;
+var init_get5 = __esm({
+  "src/commands/leads/get.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    leadsGetCommand = {
+      name: "leads_get",
+      group: "leads",
+      subcommand: "get",
+      description: "Get lead details by LinkedIn profile URL.",
+      examples: ['heyreach leads get --profile-url "https://linkedin.com/in/janedoe" --pretty'],
+      inputSchema: z25.object({
+        profileUrl: z25.string().describe("LinkedIn profile URL")
+      }),
+      cliMappings: {
+        options: [
+          { field: "profileUrl", flags: "--profile-url <url>", description: "LinkedIn profile URL" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/lead/GetLead" },
+      fieldMappings: { profileUrl: "body" },
+      handler: (input, client) => executeCommand(leadsGetCommand, input, client)
+    };
+  }
+});
+
+// src/commands/leads/add-tags.ts
+import { z as z26 } from "zod";
+var leadsAddTagsCommand;
+var init_add_tags = __esm({
+  "src/commands/leads/add-tags.ts"() {
+    "use strict";
+    init_esm_shims();
+    leadsAddTagsCommand = {
+      name: "leads_add_tags",
+      group: "leads",
+      subcommand: "add-tags",
+      description: "Add tags to a lead. Existing tags unchanged.",
+      examples: ['heyreach leads add-tags --profile-url "https://linkedin.com/in/jane" --tags "hot,priority" --create-if-missing'],
+      inputSchema: z26.object({
+        tags: z26.string().describe("Comma-separated tag names"),
+        createTagIfNotExisting: z26.coerce.boolean().default(true).describe("Create tag if it does not exist"),
+        leadProfileUrl: z26.string().optional().describe("Lead LinkedIn profile URL"),
+        leadLinkedInId: z26.string().optional().describe("Lead LinkedIn member ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "tags", flags: "--tags <list>", description: "Comma-separated tag names" },
+          { field: "createTagIfNotExisting", flags: "--create-if-missing", description: "Create tag if it does not exist" },
+          { field: "leadProfileUrl", flags: "--profile-url <url>", description: "Lead LinkedIn profile URL" },
+          { field: "leadLinkedInId", flags: "--linkedin-id <id>", description: "Lead LinkedIn member ID" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/lead/AddTags" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const tagList = input.tags.split(",").map((s) => s.trim());
+        const body = {
+          tags: tagList,
+          createTagIfNotExisting: input.createTagIfNotExisting
+        };
+        if (input.leadProfileUrl) body.leadProfileUrl = input.leadProfileUrl;
+        if (input.leadLinkedInId) body.leadLinkedInId = input.leadLinkedInId;
+        return client.request({ method: "POST", path: "/lead/AddTags", body });
+      }
+    };
+  }
+});
+
+// src/commands/leads/get-tags.ts
+import { z as z27 } from "zod";
+var leadsGetTagsCommand;
+var init_get_tags = __esm({
+  "src/commands/leads/get-tags.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    leadsGetTagsCommand = {
+      name: "leads_get_tags",
+      group: "leads",
+      subcommand: "get-tags",
+      description: "Get tags for a lead, alphabetically sorted.",
+      examples: ['heyreach leads get-tags --profile-url "https://linkedin.com/in/janedoe"'],
+      inputSchema: z27.object({
+        profileUrl: z27.string().describe("LinkedIn profile URL")
+      }),
+      cliMappings: {
+        options: [
+          { field: "profileUrl", flags: "--profile-url <url>", description: "LinkedIn profile URL" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/lead/GetTags" },
+      fieldMappings: { profileUrl: "body" },
+      handler: (input, client) => executeCommand(leadsGetTagsCommand, input, client)
+    };
+  }
+});
+
+// src/commands/leads/replace-tags.ts
+import { z as z28 } from "zod";
+var leadsReplaceTagsCommand;
+var init_replace_tags = __esm({
+  "src/commands/leads/replace-tags.ts"() {
+    "use strict";
+    init_esm_shims();
+    leadsReplaceTagsCommand = {
+      name: "leads_replace_tags",
+      group: "leads",
+      subcommand: "replace-tags",
+      description: "Remove existing tags and replace with new tags.",
+      examples: ['heyreach leads replace-tags --profile-url "https://linkedin.com/in/jane" --tags "vip,enterprise"'],
+      inputSchema: z28.object({
+        tags: z28.string().describe("Comma-separated tag names"),
+        createTagIfNotExisting: z28.coerce.boolean().default(true).describe("Create tag if it does not exist"),
+        leadProfileUrl: z28.string().optional().describe("Lead LinkedIn profile URL"),
+        leadLinkedInId: z28.string().optional().describe("Lead LinkedIn member ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "tags", flags: "--tags <list>", description: "Comma-separated tag names" },
+          { field: "createTagIfNotExisting", flags: "--create-if-missing", description: "Create tag if it does not exist" },
+          { field: "leadProfileUrl", flags: "--profile-url <url>", description: "Lead LinkedIn profile URL" },
+          { field: "leadLinkedInId", flags: "--linkedin-id <id>", description: "Lead LinkedIn member ID" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/lead/ReplaceTags" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const tagList = input.tags.split(",").map((s) => s.trim());
+        const body = {
+          tags: tagList,
+          createTagIfNotExisting: input.createTagIfNotExisting
+        };
+        if (input.leadProfileUrl) body.leadProfileUrl = input.leadProfileUrl;
+        if (input.leadLinkedInId) body.leadLinkedInId = input.leadLinkedInId;
+        return client.request({ method: "POST", path: "/lead/ReplaceTags", body });
+      }
+    };
+  }
+});
+
+// src/commands/leads/index.ts
+var leadCommands;
+var init_leads = __esm({
+  "src/commands/leads/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_get5();
+    init_add_tags();
+    init_get_tags();
+    init_replace_tags();
+    leadCommands = [
+      leadsGetCommand,
+      leadsAddTagsCommand,
+      leadsGetTagsCommand,
+      leadsReplaceTagsCommand
+    ];
+  }
+});
+
+// src/commands/lead-tags/create.ts
+import { z as z29 } from "zod";
+var leadTagsCreateCommand;
+var init_create2 = __esm({
+  "src/commands/lead-tags/create.ts"() {
+    "use strict";
+    init_esm_shims();
+    leadTagsCreateCommand = {
+      name: "lead_tags_create",
+      group: "lead-tags",
+      subcommand: "create",
+      description: "Create one or multiple tags for your workspace. Colors: Blue, Green, Purple, Pink, Red, Cyan, Yellow, Orange.",
+      examples: [`heyreach lead-tags create --tags-json '[{"displayName":"VIP","color":"Purple"}]'`],
+      inputSchema: z29.object({
+        tagsJson: z29.string().describe("JSON array of tag objects with displayName and color")
+      }),
+      cliMappings: {
+        options: [
+          { field: "tagsJson", flags: "--tags-json <json>", description: "JSON array of {displayName, color} objects" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/lead_tags/CreateTags" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const tags = JSON.parse(input.tagsJson);
+        return client.request({
+          method: "POST",
+          path: "/lead_tags/CreateTags",
+          body: { tags }
+        });
+      }
+    };
+  }
+});
+
+// src/commands/lead-tags/index.ts
+var leadTagCommands;
+var init_lead_tags = __esm({
+  "src/commands/lead-tags/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_create2();
+    leadTagCommands = [leadTagsCreateCommand];
+  }
+});
+
+// src/commands/webhooks/create.ts
+import { z as z30 } from "zod";
+var webhooksCreateCommand;
+var init_create3 = __esm({
+  "src/commands/webhooks/create.ts"() {
+    "use strict";
+    init_esm_shims();
+    webhooksCreateCommand = {
+      name: "webhooks_create",
+      group: "webhooks",
+      subcommand: "create",
+      description: "Create a webhook. Event types: CONNECTION_REQUEST_SENT, CONNECTION_REQUEST_ACCEPTED, MESSAGE_SENT, MESSAGE_REPLY_RECEIVED, INMAIL_SENT, INMAIL_REPLY_RECEIVED, EVERY_MESSAGE_REPLY_RECEIVED, FOLLOW_SENT, LIKED_POST, VIEWED_PROFILE, CAMPAIGN_COMPLETED, LEAD_TAG_UPDATED.",
+      examples: ['heyreach webhooks create --name "Replies" --url "https://example.com/hook" --event-type MESSAGE_REPLY_RECEIVED'],
+      inputSchema: z30.object({
+        webhookName: z30.string().describe("Webhook name"),
+        webhookUrl: z30.string().describe("Webhook URL"),
+        eventType: z30.string().describe("Event type"),
+        campaignIds: z30.string().optional().describe("Comma-separated campaign IDs (empty = all)")
+      }),
+      cliMappings: {
+        options: [
+          { field: "webhookName", flags: "--name <name>", description: "Webhook name" },
+          { field: "webhookUrl", flags: "--url <url>", description: "Webhook URL" },
+          { field: "eventType", flags: "--event-type <type>", description: "Event type" },
+          { field: "campaignIds", flags: "--campaign-ids <list>", description: "Comma-separated campaign IDs" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/webhooks/CreateWebhook" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const body = {
+          webhookName: input.webhookName,
+          webhookUrl: input.webhookUrl,
+          eventType: input.eventType
+        };
+        if (input.campaignIds) body.campaignIds = input.campaignIds.split(",").map((s) => Number(s.trim()));
+        return client.request({ method: "POST", path: "/webhooks/CreateWebhook", body });
+      }
+    };
+  }
+});
+
+// src/commands/webhooks/get.ts
+import { z as z31 } from "zod";
+var webhooksGetCommand;
+var init_get6 = __esm({
+  "src/commands/webhooks/get.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    webhooksGetCommand = {
+      name: "webhooks_get",
+      group: "webhooks",
+      subcommand: "get",
+      description: "Get a webhook by ID.",
+      examples: ["heyreach webhooks get --webhook-id 123 --pretty"],
+      inputSchema: z31.object({
+        webhookId: z31.coerce.number().describe("Webhook ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "webhookId", flags: "--webhook-id <id>", description: "Webhook ID" }
+        ]
+      },
+      endpoint: { method: "GET", path: "/webhooks/GetWebhookById" },
+      fieldMappings: { webhookId: "query" },
+      handler: (input, client) => executeCommand(webhooksGetCommand, input, client)
+    };
+  }
+});
+
+// src/commands/webhooks/list.ts
+import { z as z32 } from "zod";
+var webhooksListCommand;
+var init_list5 = __esm({
+  "src/commands/webhooks/list.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    webhooksListCommand = {
+      name: "webhooks_list",
+      group: "webhooks",
+      subcommand: "list",
+      description: "Get all webhooks.",
+      examples: ["heyreach webhooks list --pretty"],
+      inputSchema: z32.object({
+        offset: z32.coerce.number().default(0).describe("Pagination offset"),
+        limit: z32.coerce.number().min(1).max(100).default(100).describe("Items per page")
+      }),
+      cliMappings: {
+        options: [
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/webhooks/GetAllWebhooks" },
+      fieldMappings: { offset: "body", limit: "body" },
+      handler: (input, client) => executeCommand(webhooksListCommand, input, client)
+    };
+  }
+});
+
+// src/commands/webhooks/update.ts
+import { z as z33 } from "zod";
+var webhooksUpdateCommand;
+var init_update = __esm({
+  "src/commands/webhooks/update.ts"() {
+    "use strict";
+    init_esm_shims();
+    webhooksUpdateCommand = {
+      name: "webhooks_update",
+      group: "webhooks",
+      subcommand: "update",
+      description: "Update an existing webhook. Only provided fields are changed.",
+      examples: ['heyreach webhooks update --webhook-id 123 --name "Updated Name" --active false'],
+      inputSchema: z33.object({
+        webhookId: z33.coerce.number().describe("Webhook ID"),
+        webhookName: z33.string().optional().describe("New webhook name"),
+        webhookUrl: z33.string().optional().describe("New webhook URL"),
+        eventType: z33.string().optional().describe("New event type"),
+        campaignIds: z33.string().optional().describe("Comma-separated campaign IDs"),
+        isActive: z33.string().optional().describe("Active status: true/false")
+      }),
+      cliMappings: {
+        options: [
+          { field: "webhookId", flags: "--webhook-id <id>", description: "Webhook ID" },
+          { field: "webhookName", flags: "--name <name>", description: "New webhook name" },
+          { field: "webhookUrl", flags: "--url <url>", description: "New webhook URL" },
+          { field: "eventType", flags: "--event-type <type>", description: "New event type" },
+          { field: "campaignIds", flags: "--campaign-ids <list>", description: "Comma-separated campaign IDs" },
+          { field: "isActive", flags: "--active <bool>", description: "Active status (true/false)" }
+        ]
+      },
+      endpoint: { method: "PATCH", path: "/webhooks/UpdateWebhook" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const body = {};
+        if (input.webhookName !== void 0) body.webhookName = input.webhookName;
+        if (input.webhookUrl !== void 0) body.webhookUrl = input.webhookUrl;
+        if (input.eventType !== void 0) body.eventType = input.eventType;
+        if (input.campaignIds !== void 0) body.campaignIds = input.campaignIds.split(",").map((s) => Number(s.trim()));
+        if (input.isActive !== void 0) body.isActive = input.isActive === "true";
+        return client.request({
+          method: "PATCH",
+          path: "/webhooks/UpdateWebhook",
+          query: { webhookId: input.webhookId },
+          body
+        });
+      }
+    };
+  }
+});
+
+// src/commands/webhooks/delete.ts
+import { z as z34 } from "zod";
+var webhooksDeleteCommand;
+var init_delete = __esm({
+  "src/commands/webhooks/delete.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    webhooksDeleteCommand = {
+      name: "webhooks_delete",
+      group: "webhooks",
+      subcommand: "delete",
+      description: "Delete a webhook.",
+      examples: ["heyreach webhooks delete --webhook-id 123"],
+      inputSchema: z34.object({
+        webhookId: z34.coerce.number().describe("Webhook ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "webhookId", flags: "--webhook-id <id>", description: "Webhook ID" }
+        ]
+      },
+      endpoint: { method: "DELETE", path: "/webhooks/DeleteWebhook" },
+      fieldMappings: { webhookId: "query" },
+      handler: (input, client) => executeCommand(webhooksDeleteCommand, input, client)
+    };
+  }
+});
+
+// src/commands/webhooks/index.ts
+var webhookCommands;
+var init_webhooks = __esm({
+  "src/commands/webhooks/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_create3();
+    init_get6();
+    init_list5();
+    init_update();
+    init_delete();
+    webhookCommands = [
+      webhooksCreateCommand,
+      webhooksGetCommand,
+      webhooksListCommand,
+      webhooksUpdateCommand,
+      webhooksDeleteCommand
+    ];
+  }
+});
+
+// src/commands/network/list.ts
+import { z as z35 } from "zod";
+var networkListCommand;
+var init_list6 = __esm({
+  "src/commands/network/list.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    networkListCommand = {
+      name: "network_list",
+      group: "network",
+      subcommand: "list",
+      description: "Get paginated network connections for a LinkedIn sender. Uses pageNumber/pageSize pagination.",
+      examples: ["heyreach network list --sender-id 123 --pretty"],
+      inputSchema: z35.object({
+        senderId: z35.coerce.number().describe("LinkedIn sender account ID"),
+        pageNumber: z35.coerce.number().default(1).describe("Page number (starts at 1)"),
+        pageSize: z35.coerce.number().min(1).max(100).default(100).describe("Page size")
+      }),
+      cliMappings: {
+        options: [
+          { field: "senderId", flags: "--sender-id <id>", description: "LinkedIn sender account ID" },
+          { field: "pageNumber", flags: "--page <number>", description: "Page number" },
+          { field: "pageSize", flags: "--page-size <number>", description: "Page size" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/MyNetwork/GetMyNetworkForSender" },
+      fieldMappings: { senderId: "body", pageNumber: "body", pageSize: "body" },
+      handler: (input, client) => executeCommand(networkListCommand, input, client)
+    };
+  }
+});
+
+// src/commands/network/check.ts
+import { z as z36 } from "zod";
+var networkCheckCommand;
+var init_check = __esm({
+  "src/commands/network/check.ts"() {
+    "use strict";
+    init_esm_shims();
+    networkCheckCommand = {
+      name: "network_check",
+      group: "network",
+      subcommand: "check",
+      description: "Check if a lead is a connection of a sender. Provide exactly one of --profile-url or --linkedin-id.",
+      examples: [
+        'heyreach network check --sender-id 123 --profile-url "https://linkedin.com/in/janedoe"',
+        'heyreach network check --sender-id 123 --linkedin-id "ABC123"'
+      ],
+      inputSchema: z36.object({
+        senderAccountId: z36.coerce.number().describe("LinkedIn sender account ID"),
+        leadProfileUrl: z36.string().optional().describe("Lead LinkedIn profile URL"),
+        leadLinkedInId: z36.string().optional().describe("Lead LinkedIn member ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "senderAccountId", flags: "--sender-id <id>", description: "LinkedIn sender account ID" },
+          { field: "leadProfileUrl", flags: "--profile-url <url>", description: "Lead LinkedIn profile URL" },
+          { field: "leadLinkedInId", flags: "--linkedin-id <id>", description: "Lead LinkedIn member ID" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/MyNetwork/IsConnection" },
+      fieldMappings: { senderAccountId: "body", leadProfileUrl: "body", leadLinkedInId: "body" },
+      handler: async (input, client) => {
+        const body = { senderAccountId: input.senderAccountId };
+        if (input.leadProfileUrl) body.leadProfileUrl = input.leadProfileUrl;
+        if (input.leadLinkedInId) body.leadLinkedInId = input.leadLinkedInId;
+        return client.request({ method: "POST", path: "/MyNetwork/IsConnection", body });
+      }
+    };
+  }
+});
+
+// src/commands/network/index.ts
+var networkCommands;
+var init_network = __esm({
+  "src/commands/network/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_list6();
+    init_check();
+    networkCommands = [
+      networkListCommand,
+      networkCheckCommand
+    ];
+  }
+});
+
+// src/commands/org/api-keys.ts
+import { z as z37 } from "zod";
+var orgApiKeysCommand;
+var init_api_keys = __esm({
+  "src/commands/org/api-keys.ts"() {
+    "use strict";
+    init_esm_shims();
+    orgApiKeysCommand = {
+      name: "org_api_keys",
+      group: "org",
+      subcommand: "api-keys",
+      description: "Get API/integration keys for a workspace (requires Organization API key).",
+      examples: ["heyreach org api-keys --workspace-id 123 --pretty"],
+      inputSchema: z37.object({
+        workspaceId: z37.coerce.number().describe("Workspace ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "workspaceId", flags: "--workspace-id <id>", description: "Workspace ID" }
+        ]
+      },
+      endpoint: { method: "GET", path: "/management/organizations/api-keys/workspaces/{workspaceId}" },
+      fieldMappings: { workspaceId: "path" },
+      handler: async (input, client) => {
+        return client.request({
+          method: "GET",
+          path: `/management/organizations/api-keys/workspaces/${encodeURIComponent(String(input.workspaceId))}`
+        });
+      }
+    };
+  }
+});
+
+// src/commands/org/create-api-key.ts
+import { z as z38 } from "zod";
+var orgCreateApiKeyCommand;
+var init_create_api_key = __esm({
+  "src/commands/org/create-api-key.ts"() {
+    "use strict";
+    init_esm_shims();
+    orgCreateApiKeyCommand = {
+      name: "org_create_api_key",
+      group: "org",
+      subcommand: "create-api-key",
+      description: "Generate a new API/integration key for a workspace. Types: PUBLIC, N8N, MAKE, ZAPIER, MCP.",
+      examples: ["heyreach org create-api-key --workspace-id 123 --type PUBLIC"],
+      inputSchema: z38.object({
+        workspaceId: z38.coerce.number().describe("Workspace ID"),
+        apiKeyType: z38.string().describe("Key type: PUBLIC, N8N, MAKE, ZAPIER, MCP")
+      }),
+      cliMappings: {
+        options: [
+          { field: "workspaceId", flags: "--workspace-id <id>", description: "Workspace ID" },
+          { field: "apiKeyType", flags: "--type <type>", description: "Key type: PUBLIC, N8N, MAKE, ZAPIER, MCP" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/management/organizations/api-keys/workspaces/{workspaceId}" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        return client.request({
+          method: "POST",
+          path: `/management/organizations/api-keys/workspaces/${encodeURIComponent(String(input.workspaceId))}`,
+          body: { apiKeyType: input.apiKeyType }
+        });
+      }
+    };
+  }
+});
+
+// src/commands/org/workspaces.ts
+import { z as z39 } from "zod";
+var orgWorkspacesCommand;
+var init_workspaces = __esm({
+  "src/commands/org/workspaces.ts"() {
+    "use strict";
+    init_esm_shims();
+    orgWorkspacesCommand = {
+      name: "org_workspaces",
+      group: "org",
+      subcommand: "workspaces",
+      description: "List all workspaces in your organization (requires Organization API key).",
+      examples: ["heyreach org workspaces --pretty"],
+      inputSchema: z39.object({
+        Offset: z39.coerce.number().default(0).describe("Pagination offset"),
+        Limit: z39.coerce.number().min(1).max(100).default(100).describe("Items per page")
+      }),
+      cliMappings: {
+        options: [
+          { field: "Offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "Limit", flags: "--limit <number>", description: "Items per page" }
+        ]
+      },
+      endpoint: { method: "GET", path: "/management/organizations/workspaces" },
+      fieldMappings: { Offset: "query", Limit: "query" },
+      handler: async (input, client) => {
+        return client.request({
+          method: "GET",
+          path: "/management/organizations/workspaces",
+          query: { Offset: input.Offset, Limit: input.Limit }
+        });
+      }
+    };
+  }
+});
+
+// src/commands/org/create-workspace.ts
+import { z as z40 } from "zod";
+var orgCreateWorkspaceCommand;
+var init_create_workspace = __esm({
+  "src/commands/org/create-workspace.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handler();
+    orgCreateWorkspaceCommand = {
+      name: "org_create_workspace",
+      group: "org",
+      subcommand: "create-workspace",
+      description: "Create a new workspace in your organization.",
+      examples: ['heyreach org create-workspace --name "Sales Team" --seats-limit 10'],
+      inputSchema: z40.object({
+        workspaceName: z40.string().describe("Workspace name"),
+        seatsLimit: z40.coerce.number().optional().describe("Seat limit (null = unlimited)")
+      }),
+      cliMappings: {
+        options: [
+          { field: "workspaceName", flags: "--name <name>", description: "Workspace name" },
+          { field: "seatsLimit", flags: "--seats-limit <number>", description: "Seat limit" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/management/organizations/workspaces" },
+      fieldMappings: { workspaceName: "body", seatsLimit: "body" },
+      handler: (input, client) => executeCommand(orgCreateWorkspaceCommand, input, client)
+    };
+  }
+});
+
+// src/commands/org/update-workspace.ts
+import { z as z41 } from "zod";
+var orgUpdateWorkspaceCommand;
+var init_update_workspace = __esm({
+  "src/commands/org/update-workspace.ts"() {
+    "use strict";
+    init_esm_shims();
+    orgUpdateWorkspaceCommand = {
+      name: "org_update_workspace",
+      group: "org",
+      subcommand: "update-workspace",
+      description: "Update a workspace in your organization.",
+      examples: ['heyreach org update-workspace --workspace-id 123 --name "New Name" --seats-limit 20'],
+      inputSchema: z41.object({
+        workspaceId: z41.coerce.number().describe("Workspace ID"),
+        workspaceName: z41.string().optional().describe("New workspace name"),
+        seatsLimit: z41.coerce.number().optional().describe("New seat limit")
+      }),
+      cliMappings: {
+        options: [
+          { field: "workspaceId", flags: "--workspace-id <id>", description: "Workspace ID" },
+          { field: "workspaceName", flags: "--name <name>", description: "New workspace name" },
+          { field: "seatsLimit", flags: "--seats-limit <number>", description: "New seat limit" }
+        ]
+      },
+      endpoint: { method: "PATCH", path: "/management/organizations/workspaces/{workspaceId}" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const body = {};
+        if (input.workspaceName !== void 0) body.workspaceName = input.workspaceName;
+        if (input.seatsLimit !== void 0) body.seatsLimit = { value: input.seatsLimit };
+        return client.request({
+          method: "PATCH",
+          path: `/management/organizations/workspaces/${encodeURIComponent(String(input.workspaceId))}`,
+          body
+        });
+      }
+    };
+  }
+});
+
+// src/commands/org/users.ts
+import { z as z42 } from "zod";
+var orgUsersCommand;
+var init_users = __esm({
+  "src/commands/org/users.ts"() {
+    "use strict";
+    init_esm_shims();
+    orgUsersCommand = {
+      name: "org_users",
+      group: "org",
+      subcommand: "users",
+      description: "Get all existing and invited users in your organization.",
+      examples: ["heyreach org users --pretty", "heyreach org users --role Admin"],
+      inputSchema: z42.object({
+        offset: z42.coerce.number().default(0).describe("Pagination offset"),
+        limit: z42.coerce.number().min(1).max(100).default(100).describe("Items per page"),
+        role: z42.string().optional().describe("Filter by role: Admin, Member, Manager"),
+        invitationStatus: z42.string().optional().describe("Comma-separated statuses: Accepted, Pending, Expired, Revoked")
+      }),
+      cliMappings: {
+        options: [
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" },
+          { field: "role", flags: "--role <role>", description: "Filter by role" },
+          { field: "invitationStatus", flags: "--invitation-status <list>", description: "Comma-separated invitation statuses" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/management/organizations/users" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const body = { offset: input.offset, limit: input.limit };
+        if (input.role) body.role = input.role;
+        if (input.invitationStatus) body.invitationStatus = input.invitationStatus.split(",").map((s) => s.trim());
+        return client.request({ method: "POST", path: "/management/organizations/users", body });
+      }
+    };
+  }
+});
+
+// src/commands/org/get-user.ts
+import { z as z43 } from "zod";
+var orgGetUserCommand;
+var init_get_user = __esm({
+  "src/commands/org/get-user.ts"() {
+    "use strict";
+    init_esm_shims();
+    orgGetUserCommand = {
+      name: "org_get_user",
+      group: "org",
+      subcommand: "get-user",
+      description: "Get information about a user by ID.",
+      examples: ["heyreach org get-user --user-id 456 --pretty"],
+      inputSchema: z43.object({
+        userId: z43.coerce.number().describe("User ID")
+      }),
+      cliMappings: {
+        options: [
+          { field: "userId", flags: "--user-id <id>", description: "User ID" }
+        ]
+      },
+      endpoint: { method: "GET", path: "/management/organizations/users/{userId}" },
+      fieldMappings: { userId: "path" },
+      handler: async (input, client) => {
+        return client.request({
+          method: "GET",
+          path: `/management/organizations/users/${encodeURIComponent(String(input.userId))}`
+        });
+      }
+    };
+  }
+});
+
+// src/commands/org/workspace-users.ts
+import { z as z44 } from "zod";
+var orgWorkspaceUsersCommand;
+var init_workspace_users = __esm({
+  "src/commands/org/workspace-users.ts"() {
+    "use strict";
+    init_esm_shims();
+    orgWorkspaceUsersCommand = {
+      name: "org_workspace_users",
+      group: "org",
+      subcommand: "workspace-users",
+      description: "Get all users in a given workspace with role and permissions.",
+      examples: ["heyreach org workspace-users --workspace-id 123 --pretty"],
+      inputSchema: z44.object({
+        workspaceId: z44.coerce.number().describe("Workspace ID"),
+        offset: z44.coerce.number().default(0).describe("Pagination offset"),
+        limit: z44.coerce.number().min(1).max(100).default(100).describe("Items per page"),
+        role: z44.string().optional().describe("Filter by role"),
+        invitationStatus: z44.string().optional().describe("Comma-separated invitation statuses")
+      }),
+      cliMappings: {
+        options: [
+          { field: "workspaceId", flags: "--workspace-id <id>", description: "Workspace ID" },
+          { field: "offset", flags: "--offset <number>", description: "Pagination offset" },
+          { field: "limit", flags: "--limit <number>", description: "Items per page" },
+          { field: "role", flags: "--role <role>", description: "Filter by role" },
+          { field: "invitationStatus", flags: "--invitation-status <list>", description: "Comma-separated invitation statuses" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/management/organizations/users/workspaces/{workspaceId}" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        const body = { offset: input.offset, limit: input.limit };
+        if (input.role) body.role = input.role;
+        if (input.invitationStatus) body.invitationStatus = input.invitationStatus.split(",").map((s) => s.trim());
+        return client.request({
+          method: "POST",
+          path: `/management/organizations/users/workspaces/${encodeURIComponent(String(input.workspaceId))}`,
+          body
+        });
+      }
+    };
+  }
+});
+
+// src/commands/org/invite-admins.ts
+import { z as z45 } from "zod";
+var orgInviteAdminsCommand;
+var init_invite_admins = __esm({
+  "src/commands/org/invite-admins.ts"() {
+    "use strict";
+    init_esm_shims();
+    orgInviteAdminsCommand = {
+      name: "org_invite_admins",
+      group: "org",
+      subcommand: "invite-admins",
+      description: "Invite users as organization admins. Returns invitation URLs (no email sent).",
+      examples: ['heyreach org invite-admins --inviter-email "admin@co.com" --emails "user1@co.com,user2@co.com"'],
+      inputSchema: z45.object({
+        inviterEmail: z45.string().describe("Email of the inviter"),
+        emails: z45.string().describe("Comma-separated emails to invite")
+      }),
+      cliMappings: {
+        options: [
+          { field: "inviterEmail", flags: "--inviter-email <email>", description: "Inviter email" },
+          { field: "emails", flags: "--emails <list>", description: "Comma-separated emails" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/management/organizations/users/invite/admins" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        return client.request({
+          method: "POST",
+          path: "/management/organizations/users/invite/admins",
+          body: {
+            inviterEmail: input.inviterEmail,
+            emails: input.emails.split(",").map((s) => s.trim())
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/commands/org/invite-members.ts
+import { z as z46 } from "zod";
+var orgInviteMembersCommand;
+var init_invite_members = __esm({
+  "src/commands/org/invite-members.ts"() {
+    "use strict";
+    init_esm_shims();
+    orgInviteMembersCommand = {
+      name: "org_invite_members",
+      group: "org",
+      subcommand: "invite-members",
+      description: "Invite users as members with specified workspace permissions. Returns invitation URLs (no email sent).",
+      examples: [`heyreach org invite-members --inviter-email "admin@co.com" --emails "user@co.com" --workspace-ids "1,2" --permissions-json '{"viewCampaigns":true}'`],
+      inputSchema: z46.object({
+        inviterEmail: z46.string().describe("Email of the inviter"),
+        emails: z46.string().describe("Comma-separated emails to invite"),
+        workspaceIds: z46.string().describe("Comma-separated workspace IDs"),
+        permissionsJson: z46.string().describe("JSON object of permission booleans")
+      }),
+      cliMappings: {
+        options: [
+          { field: "inviterEmail", flags: "--inviter-email <email>", description: "Inviter email" },
+          { field: "emails", flags: "--emails <list>", description: "Comma-separated emails" },
+          { field: "workspaceIds", flags: "--workspace-ids <list>", description: "Comma-separated workspace IDs" },
+          { field: "permissionsJson", flags: "--permissions-json <json>", description: "JSON permissions object" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/management/organizations/users/invite/members" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        return client.request({
+          method: "POST",
+          path: "/management/organizations/users/invite/members",
+          body: {
+            inviterEmail: input.inviterEmail,
+            emails: input.emails.split(",").map((s) => s.trim()),
+            workspaceIds: input.workspaceIds.split(",").map((s) => Number(s.trim())),
+            permissions: JSON.parse(input.permissionsJson)
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/commands/org/invite-managers.ts
+import { z as z47 } from "zod";
+var orgInviteManagersCommand;
+var init_invite_managers = __esm({
+  "src/commands/org/invite-managers.ts"() {
+    "use strict";
+    init_esm_shims();
+    orgInviteManagersCommand = {
+      name: "org_invite_managers",
+      group: "org",
+      subcommand: "invite-managers",
+      description: "Invite users as managers (external users with workspace access, auto-added without registration).",
+      examples: ['heyreach org invite-managers --inviter-email "admin@co.com" --emails "manager@co.com" --workspace-ids "1,2"'],
+      inputSchema: z47.object({
+        inviterEmail: z47.string().describe("Email of the inviter"),
+        emails: z47.string().describe("Comma-separated emails to invite"),
+        workspaceIds: z47.string().describe("Comma-separated workspace IDs")
+      }),
+      cliMappings: {
+        options: [
+          { field: "inviterEmail", flags: "--inviter-email <email>", description: "Inviter email" },
+          { field: "emails", flags: "--emails <list>", description: "Comma-separated emails" },
+          { field: "workspaceIds", flags: "--workspace-ids <list>", description: "Comma-separated workspace IDs" }
+        ]
+      },
+      endpoint: { method: "POST", path: "/management/organizations/users/invite/managers" },
+      fieldMappings: {},
+      handler: async (input, client) => {
+        return client.request({
+          method: "POST",
+          path: "/management/organizations/users/invite/managers",
+          body: {
+            inviterEmail: input.inviterEmail,
+            emails: input.emails.split(",").map((s) => s.trim()),
+            workspaceIds: input.workspaceIds.split(",").map((s) => Number(s.trim()))
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/commands/org/index.ts
+var orgCommands;
+var init_org = __esm({
+  "src/commands/org/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_api_keys();
+    init_create_api_key();
+    init_workspaces();
+    init_create_workspace();
+    init_update_workspace();
+    init_users();
+    init_get_user();
+    init_workspace_users();
+    init_invite_admins();
+    init_invite_members();
+    init_invite_managers();
+    orgCommands = [
+      orgApiKeysCommand,
+      orgCreateApiKeyCommand,
+      orgWorkspacesCommand,
+      orgCreateWorkspaceCommand,
+      orgUpdateWorkspaceCommand,
+      orgUsersCommand,
+      orgGetUserCommand,
+      orgWorkspaceUsersCommand,
+      orgInviteAdminsCommand,
+      orgInviteMembersCommand,
+      orgInviteManagersCommand
+    ];
+  }
+});
+
+// src/commands/index.ts
+import { createInterface } from "readline/promises";
+var allCommands;
+var init_commands = __esm({
+  "src/commands/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_auth();
+    init_client();
+    init_config();
+    init_output();
+    init_errors();
+    init_campaigns();
+    init_inbox();
+    init_accounts();
+    init_lists();
+    init_stats();
+    init_leads();
+    init_lead_tags();
+    init_webhooks();
+    init_network();
+    init_org();
+    allCommands = [
+      ...campaignCommands,
+      ...inboxCommands,
+      ...accountCommands,
+      ...listCommands,
+      ...statsCommands,
+      ...leadCommands,
+      ...leadTagCommands,
+      ...webhookCommands,
+      ...networkCommands,
+      ...orgCommands
+    ];
+  }
+});
+
+// src/mcp-entry.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function startMcpFromCli() {
+  const auth = resolveAuth();
+  const client = createClient(auth);
+  const server = new McpServer({
+    name: "heyreach",
+    version: "0.1.0"
+  });
+  for (const cmdDef of allCommands) {
+    const zodShape = {};
+    const shape = cmdDef.inputSchema.shape;
+    for (const [key, val] of Object.entries(shape)) {
+      zodShape[key] = val;
+    }
+    server.tool(
+      cmdDef.name,
+      cmdDef.description,
+      zodShape,
+      async (args) => {
+        try {
+          const parsed = cmdDef.inputSchema.safeParse(args);
+          if (!parsed.success) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({ error: parsed.error.message, code: "VALIDATION_ERROR" })
+                }
+              ],
+              isError: true
+            };
+          }
+          const result = await cmdDef.handler(parsed.data, client);
+          return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+          };
+        } catch (error) {
+          return {
+            content: [
+              { type: "text", text: JSON.stringify(formatError(error)) }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var init_mcp_entry = __esm({
+  "src/mcp-entry.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_commands();
+    init_auth();
+    init_client();
+    init_errors();
+  }
+});
+
+// src/mcp.ts
+init_esm_shims();
+init_mcp_entry();
+startMcpFromCli().catch((err) => {
+  console.error("Failed to start MCP server:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=mcp.js.map