@dialerr/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dialerr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# @dialerr/mcp
+
+MCP server for **Dialerr** — lets your AI coding assistant (Claude Code, Claude
+Desktop, Cursor, …) add the Dialerr softphone widget to your project, including
+**provisioning an embed key for you** via a browser-approved flow. You approve
+in your own browser; no password or secret ever passes through a command line.
+
+## Add to Claude Code
+
+```bash
+claude mcp add dialerr -- npx -y @dialerr/mcp
+```
+
+## Add to Claude Desktop / Cursor
+
+```json
+{
+  "mcpServers": {
+    "dialerr": { "command": "npx", "args": ["-y", "@dialerr/mcp"] }
+  }
+}
+```
+
+## Then just ask
+
+> "Add a phone dialer to my app with Dialerr"
+
+The assistant will:
+1. Call `dialerr_start_key_provisioning` → you get a link like
+   `https://dialerr.com/device?code=XXXX-XXXX`.
+2. You open it, sign in (or create an account), and click **Authorize** — that
+   provisions an embed key for your organization.
+3. The assistant picks up the key, adds the widget snippet to your project, and
+   puts the secret in `.env.local` (server-side only).
+
+## Tools
+
+| Tool | What it does |
+|------|--------------|
+| `dialerr_get_install_guide` | The official install guide (script tag, frameworks, seamless sign-in route, security rules). |
+| `dialerr_start_key_provisioning` | Starts the browser-approval flow; returns the link + polling code. |
+| `dialerr_check_key_provisioning` | Polls for approval; returns the keys exactly once. |
+
+## Security notes
+
+- This server only calls the Dialerr API (`https://dialerr.com`; override with
+  `DIALERR_BASE`). It reads no files and runs no commands.
+- The **publishable** key (`pk_…`) is safe in client code (like Stripe's).
+- The **secret** key (`sk_…`) belongs only in a server env var
+  (`DIALERR_SECRET`); the assistant is instructed to write it only to
+  `.env.local`.
+- Keys are shown once; manage/revoke them at dialerr.com → Settings → API
+  Access, and restrict them to your domains before production.
+
+Docs: https://dialerr.com/llms.txt · https://dialerr.com/embed

package/bin/server.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+'use strict';
+/*
+ * Dialerr MCP server — lets an AI coding assistant add the Dialerr softphone
+ * widget to a project, including provisioning an embed key via a
+ * browser-approved device flow (the human approves in their own browser; no
+ * password or secret ever passes through a command line).
+ *
+ * Tools:
+ *   dialerr_get_install_guide       — how to embed the widget (script tag first)
+ *   dialerr_start_key_provisioning  — begin device login; returns a URL the
+ *                                     user opens + a deviceCode to poll with
+ *   dialerr_check_key_provisioning  — poll; on approval returns the keys once
+ *
+ * This server calls only the Dialerr API (default https://dialerr.com; override
+ * with DIALERR_BASE). It reads no files and runs no commands.
+ */
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { ListToolsRequestSchema, CallToolRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
+
+const BASE = (process.env.DIALERR_BASE || 'https://dialerr.com').replace(/\/$/, '');
+
+async function api(path, body) {
+  const res = await fetch(BASE + path, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body || {}),
+  });
+  let json = null;
+  try { json = await res.json(); } catch (e) {}
+  return { status: res.status, json };
+}
+
+const INSTALL_GUIDE = `# Installing the Dialerr softphone widget
+
+The recommended install is ONE SCRIPT TAG — nothing to install or run. It loads
+the official widget from dialerr.com in a sandboxed iframe. Add before </body>
+(or the framework equivalent below):
+
+  <script src="${BASE}/embed.js" data-key="pk_..."></script>
+
+The publishable key (pk_...) is designed for client-side code, like Stripe's
+pk_ — safe in page HTML. Get one with the dialerr_start_key_provisioning tool,
+or the user can copy one from ${BASE} -> Settings -> API Access.
+
+Framework placement:
+- Next.js (App Router): in app/layout.tsx via next/script, or add a small
+  client component that appends the script tag once.
+- React / Vite / CRA: add the tag to index.html, or "npm i @dialerr/embed" and
+  render <DialerrToolbar dataKey="pk_..." /> (import from '@dialerr/embed/react').
+- Plain HTML / Webflow / WordPress: paste the tag before </body>.
+
+That alone works — the user signs into Dialerr inside the widget.
+
+## Seamless sign-in (recommended for apps with a backend)
+Add a backend route that mints a short-lived token using the SECRET key, then
+point the widget at it with data-token-url="/api/dialerr/token".
+
+Next.js route (app/api/dialerr/token/route.ts):
+
+  export async function GET() {
+    const r = await fetch('${BASE}/api/v1/embed/token', {
+      method: 'POST',
+      headers: { Authorization: \`Bearer \${process.env.DIALERR_SECRET}\` },
+      body: JSON.stringify({ /* agentEmail: currentUser.email */ }),
+    });
+    return new Response(await r.text(), { headers: { 'content-type': 'application/json' } });
+  }
+
+## Hard rules
+- The SECRET key (sk_...) goes ONLY in a server env var (DIALERR_SECRET in
+  .env.local). Never in client code, commands, or commits.
+- The site must be HTTPS (or localhost) for the microphone.
+- Host-page API: window.Dialerr.open()/.startCall(phone)/.on('call_ended', cb);
+  DOM events like 'dialerr:call_connected' also fire.
+- The user should restrict the key to their domains in Settings -> API Access
+  before production.
+
+Full reference: ${BASE}/llms.txt`;
+
+const TOOLS = [
+  {
+    name: 'dialerr_get_install_guide',
+    description:
+      'How to add the Dialerr softphone widget (browser calling) to a web project. ' +
+      'Returns the official script-tag snippet, framework placement, the optional seamless ' +
+      'sign-in route, and security rules. Call this before editing files.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    name: 'dialerr_start_key_provisioning',
+    description:
+      'Provision a Dialerr embed key (pk_/sk_) for the user via a browser-approved device flow. ' +
+      'Returns a URL for the USER to open and approve in their own browser (they sign in or create ' +
+      'an account there — no credentials pass through this tool), plus a deviceCode for polling. ' +
+      'After the user says they approved, call dialerr_check_key_provisioning.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    name: 'dialerr_check_key_provisioning',
+    description:
+      'Check whether the user approved the device flow started by dialerr_start_key_provisioning. ' +
+      'Returns pending, or the provisioned keys exactly once.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        deviceCode: { type: 'string', description: 'The deviceCode returned by dialerr_start_key_provisioning (dc_...)' },
+      },
+      required: ['deviceCode'],
+      additionalProperties: false,
+    },
+  },
+];
+
+function text(t) { return { content: [{ type: 'text', text: t }] }; }
+
+async function handleCall(name, args) {
+  if (name === 'dialerr_get_install_guide') return text(INSTALL_GUIDE);
+
+  if (name === 'dialerr_start_key_provisioning') {
+    const r = await api('/api/v1/embed/device/code');
+    if (r.status !== 200 || !r.json || !r.json.deviceCode) {
+      return text(`Could not start key provisioning (HTTP ${r.status}). The user can instead copy a key from ${BASE} -> Settings -> API Access.`);
+    }
+    const d = r.json;
+    return text(
+      `Ask the user to open this link in their browser and click Authorize (sign in or create a Dialerr account if needed):\n\n` +
+      `  ${d.verificationUriComplete}\n\n` +
+      `Code shown on the page: ${d.userCode}  (expires in ${Math.round((d.expiresIn || 600) / 60)} minutes)\n\n` +
+      `When the user says they approved, call dialerr_check_key_provisioning with deviceCode: ${d.deviceCode}`,
+    );
+  }
+
+  if (name === 'dialerr_check_key_provisioning') {
+    const deviceCode = String((args && args.deviceCode) || '');
+    if (!deviceCode.startsWith('dc_')) return text('Invalid deviceCode — it should start with dc_. Start over with dialerr_start_key_provisioning.');
+    const r = await api('/api/v1/embed/device/token', { deviceCode });
+    if (r.status === 410) return text('That device flow expired or its keys were already claimed. Start over with dialerr_start_key_provisioning.');
+    if (r.json && r.json.status === 'pending') return text('Not approved yet. Ask the user to open the link and click Authorize, then call this tool again.');
+    if (r.json && r.json.status === 'approved') {
+      return text(
+        `Approved! Keys provisioned:\n\n` +
+        `Publishable key (safe in client code): ${r.json.publicKey}\n` +
+        `Secret key (SERVER-SIDE ONLY): ${r.json.secretKey}\n\n` +
+        `Handling rules:\n` +
+        `- Use the publishable key in the embed snippet: <script src="${BASE}/embed.js" data-key="${r.json.publicKey}"></script>\n` +
+        `- Write the secret ONLY to .env.local as DIALERR_SECRET=... (never client code, commands, or commits).\n` +
+        `- These keys are shown once. Tell the user they can manage/revoke the key at ${BASE} -> Settings -> API Access, and should restrict it to their domains before production.\n\n` +
+        `Now call dialerr_get_install_guide for the exact snippet + optional seamless sign-in route.`,
+      );
+    }
+    return text(`Unexpected response (HTTP ${r.status}). Try again, or start over with dialerr_start_key_provisioning.`);
+  }
+
+  return text(`Unknown tool: ${name}`);
+}
+
+const server = new Server(
+  { name: 'dialerr', version: '0.1.0' },
+  { capabilities: { tools: {} } },
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  try {
+    return await handleCall(req.params.name, req.params.arguments || {});
+  } catch (e) {
+    return text(`Error: ${e.message}`);
+  }
+});
+
+(async () => {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+})();

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@dialerr/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Dialerr — lets AI coding assistants provision an embed key (browser-approved) and install the Dialerr softphone widget.",
+  "bin": {
+    "dialerr-mcp": "bin/server.js"
+  },
+  "type": "commonjs",
+  "files": [
+    "bin",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "dialerr",
+    "mcp",
+    "modelcontextprotocol",
+    "softphone",
+    "webrtc",
+    "dialer",
+    "embed",
+    "widget"
+  ],
+  "author": "Dialerr <steven@dialerr.com> (https://dialerr.com)",
+  "homepage": "https://dialerr.com/embed",
+  "bugs": {
+    "email": "support@dialerr.com"
+  },
+  "license": "MIT"
+}