send-to-poke-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Konark Mangudkar
+
+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,72 @@
+# send-to-poke-mcp
+
+Minimal MCP server for sending messages to Poke via the inbound webhook.
+
+## Features
+- Single MCP tool: `send_to_poke`
+- Sends a message to Poke using the inbound webhook
+- Structured tool output with normalized response
+
+## Requirements
+- Node.js >= 18
+- `POKE_API_KEY` environment variable
+
+## MCP client config
+Add the following config to your MCP client:
+```json
+{
+  "mcpServers": {
+    "send-to-poke": {
+      "command": "npx",
+      "args": ["-y", "send-to-poke-mcp"],
+      "env": {
+        "POKE_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+## Local development
+```bash
+npm install
+npm run build
+```
+
+## Smoke test (optional)
+```bash
+POKE_API_KEY=your-api-key-here npm run build
+POKE_API_KEY=your-api-key-here npm run smoke-test
+```
+Note: this test requires network access and may fail in restricted environments.
+
+## MCP Tool
+### `send_to_poke`
+Send a message to Poke.
+
+**Input**
+```json
+{
+  "message": "string",
+  "include_raw_response": false
+}
+```
+
+**Output**
+```json
+{
+  "status": "sent",
+  "http_status": 200,
+  "response": {},
+  "raw_response": ""
+}
+```
+
+## Environment Variables
+- `POKE_API_KEY` (required)
+- `POKE_BASE_URL` (default: `https://poke.com`)
+- `POKE_TIMEOUT` (default: `30000`)
+
+## Notes
+- Tool responses are returned as MCP `structuredContent` (with a text fallback for display).
+- This project is not affiliated with Interaction Co.

package/bin/send-to-poke-mcp

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/index.js

@@ -0,0 +1,123 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+const DEFAULT_BASE_URL = "https://poke.com";
+const DEFAULT_TIMEOUT_MS = 30000;
+const SendToPokeInputBaseSchema = z.object({
+    message: z.string().min(1).describe("Message to send to Poke"),
+    include_raw_response: z
+        .boolean()
+        .optional()
+        .describe("Include raw response text for debugging"),
+});
+const SendToPokeInputSchema = SendToPokeInputBaseSchema.superRefine((data, ctx) => {
+    if (data.message.trim().length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "message cannot be empty",
+            path: ["message"],
+        });
+    }
+});
+const SendToPokeOutputSchema = z.object({
+    status: z.literal("sent"),
+    http_status: z.number(),
+    response: z.unknown(),
+    raw_response: z.string().optional(),
+});
+async function fetchWithTimeout(url, options, timeoutMs) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, { ...options, signal: controller.signal });
+        const text = await response.text();
+        return { response, text };
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+const server = new McpServer({
+    name: "send-to-poke-mcp",
+    version: "0.1.0",
+});
+server.registerTool("send_to_poke", {
+    title: "Send to Poke",
+    description: "Send a message to Poke using the inbound webhook.",
+    inputSchema: SendToPokeInputBaseSchema,
+    outputSchema: SendToPokeOutputSchema,
+    annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+}, async (args) => {
+    try {
+        const parsedArgs = SendToPokeInputSchema.parse(args);
+        const apiKey = process.env.POKE_API_KEY;
+        if (!apiKey) {
+            throw new Error("POKE_API_KEY is required");
+        }
+        const baseUrl = process.env.POKE_BASE_URL ?? DEFAULT_BASE_URL;
+        const timeoutMs = Number.parseInt(process.env.POKE_TIMEOUT ?? String(DEFAULT_TIMEOUT_MS), 10);
+        const message = parsedArgs.message.trim();
+        const url = `${baseUrl}/api/v1/inbound-sms/webhook`;
+        const { response, text } = await fetchWithTimeout(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ message }),
+        }, timeoutMs);
+        if (!response.ok) {
+            throw new Error(`Poke API error ${response.status}: ${text}`);
+        }
+        let parsedBody = text;
+        if (text) {
+            try {
+                parsedBody = JSON.parse(text);
+            }
+            catch {
+                parsedBody = text;
+            }
+        }
+        const payload = {
+            status: "sent",
+            http_status: response.status,
+            response: parsedBody,
+            ...(parsedArgs.include_raw_response ? { raw_response: text } : {}),
+        };
+        return {
+            structuredContent: payload,
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(payload, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("send_to_poke failed", message);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ error: message, status: "failed" }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("send-to-poke-mcp running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "send-to-poke-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for sending messages to Poke via webhook",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/konarkm/send-to-poke-mcp.git"
+  },
+  "homepage": "https://github.com/konarkm/send-to-poke-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/konarkm/send-to-poke-mcp/issues"
+  },
+  "bin": {
+    "send-to-poke-mcp": "bin/send-to-poke-mcp"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build",
+    "smoke-test": "tsx scripts/smoke-test.ts",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "poke",
+    "webhook",
+    "messaging"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.18.2",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.12.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}