@kerabie/mcp 0.0.0-stage → 1.0.1

package/dist/cli-http.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  createHttpHandler
+} from "./chunk-4MMO737J.js";
+import "./chunk-72BI6YMN.js";
+
+// src/cli-http.ts
+import { createServer as createHttpServer } from "http";
+var port = Number(process.env.PORT) || 3333;
+var server = createHttpServer(createHttpHandler({ baseUrl: process.env.KERABIE_BASE_URL }));
+server.requestTimeout = 6e4;
+server.listen(port, () => console.error(`kerabie-mcp-http listening on :${port} (POST /mcp, GET /health)`));
+for (const sig of ["SIGINT", "SIGTERM"]) process.on(sig, () => server.close(() => process.exit(0)));

package/dist/cli.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import {
+  createServer
+} from "./chunk-72BI6YMN.js";
+
+// src/cli.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { KerAbieClient } from "@kerabie/sdk";
+var apiKey = process.env.KERABIE_API_KEY;
+var client = apiKey ? new KerAbieClient({ apiKey, baseUrl: process.env.KERABIE_BASE_URL, orgId: process.env.KERABIE_ORG_ID }) : null;
+if (!client) console.error("kerabie-mcp: no KERABIE_API_KEY set, so only the documentation tools are available. Add a key (Settings > API) to work with your account.");
+var readOnly = process.env.KERABIE_MCP_READ_ONLY === "true" || process.argv.includes("--read-only");
+await createServer(client, { readOnly }).connect(new StdioServerTransport());
+console.error(`kerabie-mcp running${client ? "" : " (docs only)"}${readOnly ? " (read-only)" : ""}`);

package/dist/index.d.ts

@@ -0,0 +1,105 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { KerAbieClient } from '@kerabie/sdk';
+import { z } from 'zod';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * Every tool the server offers, as data: name, description, input schema and what it calls on the Kerabie SDK.
+ * Only API routes that exist are exposed. Tools that change anything are `write: true` (and `destructive`
+ * when they delete), so a read-only server simply leaves them out.
+ */
+interface ToolDef {
+    name: string;
+    title: string;
+    description: string;
+    input: z.ZodRawShape;
+    write?: boolean;
+    destructive?: boolean;
+    /** Answers from bundled knowledge, so it needs no API key. */
+    local?: boolean;
+    run: (c: KerAbieClient, a: any) => Promise<unknown>;
+}
+declare const TOOLS: ToolDef[];
+
+/** The most text one tool answer carries. Past it the answer says so and points at pagination. */
+declare const MAX_RESULT_CHARS = 60000;
+interface ServerOptions {
+    /** Leave out every tool that changes something. */
+    readOnly?: boolean;
+    version?: string;
+}
+/** The tools a server with these options offers. */
+declare const ALL_TOOLS: ToolDef[];
+/** The tools a server offers: with no client (no API key) only the documentation tools; read-only drops every tool that changes something. */
+declare const toolsFor: (readOnly: boolean, hasClient?: boolean) => ToolDef[];
+declare function formatResult(value: unknown): string;
+/** An API error as something the model can act on: what failed, and why. */
+declare function formatError(e: unknown): string;
+declare function createServer(client: KerAbieClient | null, opts?: ServerOptions): McpServer;
+
+/** `Authorization: Bearer ker_live_...` → the key, or null. */
+declare function bearerKey(header: string | undefined | null): string | null;
+
+interface HttpOptions {
+    /** The Kerabie API the tools call. Defaults to the SDK's own default (https://api.kerabie.com). */
+    baseUrl?: string;
+    version?: string;
+}
+/**
+ * A hosted MCP endpoint: `POST /mcp` over Streamable HTTP, one stateless server per request.
+ *
+ * The caller's own API key (`Authorization: Bearer ker_live_...`) is used for every tool call, so a person
+ * can only ever do what their key allows, and nothing is stored here. With no key only the documentation
+ * tools are offered. `?readOnly=true` leaves out every tool that changes something.
+ */
+declare function createHttpHandler(opts?: HttpOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+
+/**
+ * Tools for developers building on Kerabie: the docs, the API endpoint list, the TypeScript and React Native
+ * SDK types, and integration guides. They answer from knowledge bundled into the package, so they work without
+ * an API key and match the SDK versions that ship with it.
+ */
+declare const DEV_TOOLS: ToolDef[];
+
+interface Doc {
+    id: string;
+    url: string;
+    title: string;
+    description: string;
+    section: string;
+    body: string;
+    headings: {
+        level: number;
+        text: string;
+    }[];
+}
+interface Endpoint {
+    method: string;
+    path: string;
+    title: string;
+    doc: string;
+    sdk: string;
+}
+interface SearchHit {
+    id: string;
+    title: string;
+    section: string;
+    url: string;
+    snippet: string;
+    score: number;
+}
+/** Scores a doc by how many query words appear in its title (heavily), headings and text. */
+declare function searchDocs(query: string, opts?: {
+    section?: string;
+    limit?: number;
+}, docs?: Doc[]): SearchHit[];
+/** One doc, or only the part under `heading` (up to the next heading of the same or higher level). */
+declare function getDocText(doc: Doc, heading?: string): string | null;
+declare function findDoc(id: string, docs?: Doc[]): Doc | undefined;
+declare function searchEndpoints(query: string | undefined, endpoints?: Endpoint[]): Endpoint[];
+/** Names declared in a type source. */
+declare function listDeclarations(source: string): string[];
+/** The text of one declaration (with the doc comment above it), found by name. */
+declare function extractDeclaration(source: string, name: string): string | null;
+
+export { ALL_TOOLS, DEV_TOOLS, type HttpOptions, MAX_RESULT_CHARS, type ServerOptions, TOOLS, type ToolDef, bearerKey, createHttpHandler, createServer, extractDeclaration, findDoc, formatError, formatResult, getDocText, listDeclarations, searchDocs, searchEndpoints, toolsFor };

package/dist/index.js

@@ -0,0 +1,38 @@
+import {
+  bearerKey,
+  createHttpHandler
+} from "./chunk-4MMO737J.js";
+import {
+  ALL_TOOLS,
+  DEV_TOOLS,
+  MAX_RESULT_CHARS,
+  TOOLS,
+  createServer,
+  extractDeclaration,
+  findDoc,
+  formatError,
+  formatResult,
+  getDocText,
+  listDeclarations,
+  searchDocs,
+  searchEndpoints,
+  toolsFor
+} from "./chunk-72BI6YMN.js";
+export {
+  ALL_TOOLS,
+  DEV_TOOLS,
+  MAX_RESULT_CHARS,
+  TOOLS,
+  bearerKey,
+  createHttpHandler,
+  createServer,
+  extractDeclaration,
+  findDoc,
+  formatError,
+  formatResult,
+  getDocText,
+  listDeclarations,
+  searchDocs,
+  searchEndpoints,
+  toolsFor
+};

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@kerabie/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "MCP server for Kerabie: lets Claude, Cursor and other MCP clients work with your conversations, tickets, contacts, campaigns, knowledge base, analytics and AI tools",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "kerabie-mcp": "dist/cli.js",
+    "kerabie-mcp-http": "dist/cli-http.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "kerabie",
+    "mcp",
+    "model-context-protocol",
+    "helpdesk",
+    "customer-support"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "knowledge": "node scripts/build-knowledge.mjs",
+    "build": "node scripts/build-knowledge.mjs && tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "sync": "node scripts/build-knowledge.mjs",
+    "dev:worker": "wrangler dev",
+    "deploy": "wrangler deploy"
+  },
+  "dependencies": {
+    "@kerabie/sdk": "^1.0.1",
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^3.0.0",
+    "wrangler": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}