@kerabie/sdk 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,537 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HttpError: () => HttpError,
+  KerAbieClient: () => KerAbieClient,
+  StoreResource: () => StoreResource,
+  WebhooksResource: () => WebhooksResource
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/http.ts
+var HttpError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "HttpError";
+  }
+};
+var HttpClient = class {
+  constructor(baseUrl, apiKey, orgId, timeout = 3e4) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.apiKey = apiKey;
+    this.orgId = orgId;
+    this.timeout = timeout;
+  }
+  async request(opts) {
+    const url = new URL(this.baseUrl + opts.path);
+    if (opts.params) {
+      Object.entries(opts.params).forEach(([k, v]) => {
+        if (v !== void 0) url.searchParams.set(k, String(v));
+      });
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`
+    };
+    if (this.orgId) headers["X-Kerabie-Org"] = this.orgId;
+    try {
+      const res = await fetch(url.toString(), {
+        method: opts.method ?? "GET",
+        headers,
+        body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!res.ok) {
+        const errBody = await res.json().catch(() => ({}));
+        throw new HttpError(res.status, errBody.message ?? `HTTP ${res.status}`, errBody);
+      }
+      if (res.status === 204) return void 0;
+      return await res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  get(path, params) {
+    return this.request({ method: "GET", path, params });
+  }
+  post(path, body) {
+    return this.request({ method: "POST", path, body });
+  }
+  patch(path, body) {
+    return this.request({ method: "PATCH", path, body });
+  }
+  delete(path) {
+    return this.request({ method: "DELETE", path });
+  }
+};
+
+// src/resources/conversations.ts
+var ConversationsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/v1/conversations", params);
+  }
+  async get(id) {
+    return this.http.get(`/v1/conversations/${id}`);
+  }
+  async create(params) {
+    return this.http.post("/v1/conversations", params);
+  }
+  async update(id, params) {
+    return this.http.patch(`/v1/conversations/${id}`, params);
+  }
+  async resolve(id) {
+    return this.update(id, { status: "RESOLVED" });
+  }
+  async close(id) {
+    return this.update(id, { status: "CLOSED" });
+  }
+  async assign(id, agentId) {
+    return this.update(id, { assignedTeamMemberId: agentId });
+  }
+  /** The same customer's earlier conversations, newest first (default 5, max 20). */
+  async getHistory(id, limit) {
+    return this.http.get(`/v1/conversations/${id}/history`, { limit });
+  }
+  /**
+   * Hand a conversation from the AI assistant to a human: stops the bot and
+   * assigns `agentId` (a team-member id) if nobody holds it yet. Fails with
+   * 400 if the AI is no longer handling it.
+   */
+  async takeOver(id, params) {
+    return this.http.post(`/v1/conversations/${id}/take-over`, params);
+  }
+  async getMessages(id, params) {
+    return this.http.get(`/v1/conversations/${id}/messages`, params);
+  }
+  async sendMessage(id, params) {
+    return this.http.post(`/v1/conversations/${id}/messages`, params);
+  }
+  async delete(id) {
+    return this.http.delete(`/v1/conversations/${id}`);
+  }
+};
+
+// src/resources/customers.ts
+var CustomersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/v1/customers", params);
+  }
+  async get(id) {
+    return this.http.get(`/v1/customers/${id}`);
+  }
+  async upsert(params) {
+    return this.http.post("/v1/customers", params);
+  }
+  async update(id, params) {
+    return this.http.patch(`/v1/customers/${id}`, params);
+  }
+  async getConversations(id) {
+    return this.http.get(`/v1/customers/${id}/conversations`);
+  }
+  async delete(id) {
+    return this.http.delete(`/v1/customers/${id}`);
+  }
+};
+
+// src/resources/visitors.ts
+var VisitorsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Visitors from the last few days (online and offline) with visit counts and block/allow status. */
+  async list(params) {
+    return this.http.get("/v1/visitors", params);
+  }
+  /** Visitors on the site right now. */
+  async getActive() {
+    const { data } = await this.list({ status: "online", limit: 100 });
+    return { data };
+  }
+  /** Online now, countries and returning visitors (24h), active IP blocks, top countries. */
+  async getOverview() {
+    return this.http.get("/v1/visitors/overview");
+  }
+  /**
+   * CSV of the visitors matching the filters (max 5,000). Requires a plan with
+   * data exports (Pro and above) — otherwise throws an HttpError with status 403.
+   */
+  async export(params) {
+    return this.http.get("/v1/visitors/export", params);
+  }
+  async getPages(sessionId) {
+    return this.http.get(`/v1/visitors/${sessionId}/pages`);
+  }
+  async block(sessionId, params) {
+    return this.http.post(`/v1/visitors/${sessionId}/block`, params ?? {});
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    return this.http.get("/v1/agents");
+  }
+  async getOnline() {
+    return this.http.get("/v1/agents/online");
+  }
+  async invite(params) {
+    return this.http.post("/v1/agents/invite", params);
+  }
+};
+
+// src/resources/knowledge-base.ts
+var KnowledgeBaseResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/v1/kb/articles", params);
+  }
+  /** Totals and the categories in use. */
+  async getStats() {
+    return this.http.get("/v1/kb/stats");
+  }
+  /** What to write or fix next: most viewed, unanswered customer questions, lowest rated, and stale articles. */
+  async getInsights() {
+    return this.http.get("/v1/kb/insights");
+  }
+  async get(id) {
+    return this.http.get(`/v1/kb/articles/${id}`);
+  }
+  async search(query) {
+    return this.http.get("/v1/kb/articles", { search: query });
+  }
+  async createArticle(params) {
+    return this.http.post("/v1/kb/articles", params);
+  }
+  async updateArticle(id, params) {
+    return this.http.patch(`/v1/kb/articles/${id}`, params);
+  }
+  async deleteArticle(id) {
+    return this.http.delete(`/v1/kb/articles/${id}`);
+  }
+};
+
+// src/resources/webhooks.ts
+var import_crypto = require("crypto");
+var WebhooksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    return this.http.get("/v1/webhooks");
+  }
+  async get(id) {
+    return this.http.get(`/v1/webhooks/${id}`);
+  }
+  async create(params) {
+    return this.http.post("/v1/webhooks", params);
+  }
+  async update(id, params) {
+    return this.http.patch(`/v1/webhooks/${id}`, params);
+  }
+  async delete(id) {
+    return this.http.delete(`/v1/webhooks/${id}`);
+  }
+  /**
+   * Verify an incoming webhook signature.
+   * The signature header is `X-Kerabie-Signature`.
+   */
+  static verify(rawBody, signature, secret) {
+    const expected = (0, import_crypto.createHmac)("sha256", secret).update(rawBody).digest("hex");
+    const expectedHeader = `sha256=${expected}`;
+    try {
+      return (0, import_crypto.timingSafeEqual)(Buffer.from(expectedHeader), Buffer.from(signature));
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Parse a verified webhook payload with full TypeScript types.
+   */
+  static parse(rawBody) {
+    return JSON.parse(rawBody);
+  }
+};
+
+// src/resources/analytics.ts
+var AnalyticsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Conversation, response-time, satisfaction and AI numbers for the last `days` days (default 30), with deltas vs the previous period. */
+  async getSummary(params) {
+    return this.http.get("/v1/analytics/summary", params);
+  }
+  async getAgentStats(params) {
+    return this.http.get("/v1/analytics/agents", params);
+  }
+  /**
+   * The deeper numbers: first-response times, per-agent and per-channel results, the questions customers ask,
+   * who they are, when they write in, and which pages start conversations.
+   */
+  async getInsights(params) {
+    return this.http.get("/v1/analytics/insights", params);
+  }
+  /** Open tickets by priority, and the percentage still within their SLA. */
+  async getTicketSla() {
+    return this.http.get("/v1/analytics/tickets-sla");
+  }
+  /** Which of the first-run steps (connect a channel, train the AI, create an automation) are done. */
+  async getSetupStatus() {
+    return this.http.get("/v1/analytics/setup-status");
+  }
+};
+
+// src/resources/store.ts
+var StoreResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/v1/store/products", params);
+  }
+  async get(id) {
+    return this.http.get(`/v1/store/products/${id}`);
+  }
+};
+
+// src/resources/tickets.ts
+var TicketsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/v1/tickets", params);
+  }
+  /** Open, unassigned and SLA-breaching counts plus the 7-day average resolution time and its change. */
+  async getStats() {
+    return this.http.get("/v1/tickets/stats");
+  }
+  /**
+   * CSV of tickets matching the filters (max 5,000). Requires a plan with
+   * data exports (Pro and above) — otherwise throws an HttpError with status 403.
+   */
+  async export(params) {
+    return this.http.get("/v1/tickets/export", params);
+  }
+  async get(id) {
+    return this.http.get(`/v1/tickets/${id}`);
+  }
+  async create(params) {
+    return this.http.post("/v1/tickets", params);
+  }
+  async update(id, params) {
+    return this.http.patch(`/v1/tickets/${id}`, params);
+  }
+  async resolve(id) {
+    return this.update(id, { status: "RESOLVED" });
+  }
+  async close(id) {
+    return this.update(id, { status: "CLOSED" });
+  }
+  async reply(id, message) {
+    return this.http.post(`/v1/tickets/${id}/reply`, { message });
+  }
+};
+
+// src/resources/contacts.ts
+var ContactsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** People with a name, email or phone number, last-contacted first. */
+  async list(params) {
+    return this.http.get("/v1/contacts", params);
+  }
+  /** Totals for the overview: everyone, new this week, leads, VIPs. */
+  async getStats() {
+    return this.http.get("/v1/contacts/stats");
+  }
+  async get(id) {
+    return this.http.get(`/v1/contacts/${id}`);
+  }
+  /** Adds a contact. Needs a name, email or phone. Throws an HttpError with status 409 if the email is already saved. */
+  async create(params) {
+    return this.http.post("/v1/contacts", params);
+  }
+  async update(id, params) {
+    return this.http.patch(`/v1/contacts/${id}`, params);
+  }
+  /**
+   * Imports up to 1,000 contacts per call. Rows whose email is already saved are skipped;
+   * invalid rows are reported with their number instead of failing the whole import.
+   */
+  async import(rows) {
+    return this.http.post("/v1/contacts/import", { rows });
+  }
+};
+
+// src/resources/campaigns.ts
+var CampaignsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Proactive messages shown on your chat widget, newest first. */
+  async list(params) {
+    return this.http.get("/v1/campaigns", params);
+  }
+  /** Totals and funnel numbers, plus how many campaigns your plan lets you run at once. */
+  async getStats() {
+    return this.http.get("/v1/campaigns/stats");
+  }
+  async get(id) {
+    return this.http.get(`/v1/campaigns/${id}`);
+  }
+  /**
+   * Saves a draft, or launches it with `isActive: true`.
+   * Throws an HttpError with status 403 when launching would exceed your plan's live-campaign limit.
+   */
+  async create(params) {
+    return this.http.post("/v1/campaigns", params);
+  }
+  /** Edits fields and/or turns it on or off with `isActive`. Send only what you want to change. */
+  async update(id, params) {
+    return this.http.patch(`/v1/campaigns/${id}`, params);
+  }
+  /** A copy saved as a draft, with fresh results. */
+  async duplicate(id) {
+    return this.http.post(`/v1/campaigns/${id}/duplicate`, {});
+  }
+  async delete(id) {
+    return this.http.delete(`/v1/campaigns/${id}`);
+  }
+};
+
+// src/resources/ai-tools.ts
+var AiToolsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Your AI agent tools (custom API actions the chatbot can call), with 30-day usage and your plan's limit. */
+  async list() {
+    return this.http.get("/v1/ai-tools");
+  }
+  /** One tool. Secrets are never returned. */
+  async get(id) {
+    return this.http.get(`/v1/ai-tools/${id}`);
+  }
+  /**
+   * Adds a tool. Throws an HttpError with status 403 when your plan has no room for another,
+   * 409 when the function name is taken, and 400 for a private or local endpoint.
+   */
+  async create(params) {
+    return this.http.post("/v1/ai-tools", params);
+  }
+  /** Edits fields and/or switches the tool on or off with `enabled`. Send only what you want to change. */
+  async update(id, params) {
+    return this.http.patch(`/v1/ai-tools/${id}`, params);
+  }
+  /** A copy that starts switched off. Counts against your plan's tool limit. */
+  async duplicate(id) {
+    return this.http.post(`/v1/ai-tools/${id}/duplicate`, {});
+  }
+  async delete(id) {
+    return this.http.delete(`/v1/ai-tools/${id}`);
+  }
+  /** Calls the tool's real endpoint once with `args`, the way the AI would. Not counted as usage. Limited to 40 a hour. */
+  async test(id, args = {}) {
+    return this.http.post(`/v1/ai-tools/${id}/test`, { args });
+  }
+};
+
+// src/resources/mcp-servers.ts
+var McpServersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Connected servers, with the tools each offers and which are switched on. */
+  async list() {
+    return this.http.get("/v1/mcp-servers");
+  }
+  /**
+   * Connects a server and reads its tools. No tool is switched on yet: use `update` with `enabledTools`.
+   * Throws an HttpError with status 400 when the server can't be reached, 403 when your plan has no AI tools,
+   * and 409 when it is already connected.
+   */
+  async create(params) {
+    return this.http.post("/v1/mcp-servers", params);
+  }
+  /** Reads the server's tools again. Switched-on tools the server no longer offers are dropped. */
+  async sync(id) {
+    return this.http.post(`/v1/mcp-servers/${id}/sync`, {});
+  }
+  /** Renames, switches the server on or off, changes which tools the chatbot may use, or updates credentials. */
+  async update(id, params) {
+    return this.http.patch(`/v1/mcp-servers/${id}`, params);
+  }
+  async delete(id) {
+    return this.http.delete(`/v1/mcp-servers/${id}`);
+  }
+  /** Runs one of the server's tools once with `args`, the way the chatbot would. Limited to 40 a hour. */
+  async test(id, tool, args = {}) {
+    return this.http.post(`/v1/mcp-servers/${id}/test`, { tool, args });
+  }
+};
+
+// src/client.ts
+var KerAbieClient = class {
+  constructor(config) {
+    if (!config.apiKey) throw new Error("KerAbieClient: apiKey is required");
+    const baseUrl = config.baseUrl ?? "https://api.kerabie.com";
+    this.http = new HttpClient(baseUrl, config.apiKey, config.orgId, config.timeout);
+    this.conversations = new ConversationsResource(this.http);
+    this.customers = new CustomersResource(this.http);
+    this.visitors = new VisitorsResource(this.http);
+    this.agents = new AgentsResource(this.http);
+    this.kb = new KnowledgeBaseResource(this.http);
+    this.webhooks = new WebhooksResource(this.http);
+    this.analytics = new AnalyticsResource(this.http);
+    this.store = new StoreResource(this.http);
+    this.tickets = new TicketsResource(this.http);
+    this.contacts = new ContactsResource(this.http);
+    this.campaigns = new CampaignsResource(this.http);
+    this.aiTools = new AiToolsResource(this.http);
+    this.mcpServers = new McpServersResource(this.http);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpError,
+  KerAbieClient,
+  StoreResource,
+  WebhooksResource
+});