sendkit-mcp 0.1.0

package/dist/db.d.ts

@@ -0,0 +1,2 @@
+import { Database } from "bun:sqlite";
+export declare const db: Database;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../core/dist/index.js
+import { z } from "zod";
+var telegramMessageInputSchema = z.object({
+  chatId: z.string().min(1, "Chat ID is required"),
+  message: z.string().min(1, "Message is required")
+});
+var telegramMessageOptionsSchema = telegramMessageInputSchema.extend({
+  botToken: z.string().min(1, "Telegram bot token is required")
+});
+var telegramSendMessageRequestSchema = z.object({
+  chat_id: z.string().min(1),
+  text: z.string().min(1)
+});
+var telegramSendMessageResponseSchema = z.object({
+  ok: z.boolean(),
+  result: z.object({
+    message_id: z.number()
+  }).optional(),
+  description: z.string().optional()
+});
+var telegramMessageOutputSchema = z.object({
+  ok: z.literal(true),
+  chatId: z.string(),
+  messageId: z.number()
+});
+async function sendTelegramMessage(options) {
+  const parsedOptions = telegramMessageOptionsSchema.safeParse(options);
+  if (!parsedOptions.success) {
+    return {
+      success: false,
+      error: parsedOptions.error.issues[0]?.message ?? "Invalid input"
+    };
+  }
+  const { chatId, message, botToken } = parsedOptions.data;
+  const parsedRequestBody = telegramSendMessageRequestSchema.safeParse({
+    chat_id: chatId,
+    text: message
+  });
+  if (!parsedRequestBody.success) {
+    return {
+      success: false,
+      error: parsedRequestBody.error.issues[0]?.message ?? "Invalid request body"
+    };
+  }
+  try {
+    const res = await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(parsedRequestBody.data)
+    });
+    let rawData;
+    try {
+      rawData = await res.json();
+    } catch {
+      return {
+        success: false,
+        error: "Failed to parse Telegram API response (invalid JSON)."
+      };
+    }
+    const parsedResponse = telegramSendMessageResponseSchema.safeParse(rawData);
+    if (!parsedResponse.success) {
+      return {
+        success: false,
+        error: "Unexpected response shape from Telegram API."
+      };
+    }
+    const data = parsedResponse.data;
+    if (!res.ok || !data.ok || !data.result) {
+      return {
+        success: false,
+        error: data.description ?? `Telegram API error (HTTP ${res.status})`
+      };
+    }
+    const output = telegramMessageOutputSchema.parse({
+      ok: true,
+      chatId,
+      messageId: data.result.message_id
+    });
+    return { success: true, data: output };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    return { success: false, error: `Network error: ${msg}` };
+  }
+}
+
+// src/index.ts
+import { z as z2 } from "zod";
+var server = new McpServer({
+  name: "sendkit",
+  version: "1.0.0"
+});
+function getTelegramBotToken() {
+  const token = process.env.TELEGRAM_BOT_TOKEN;
+  if (!token) {
+    throw new Error("TELEGRAM_BOT_TOKEN is required. Configure it in your MCP client environment.");
+  }
+  return token;
+}
+server.tool("send_telegram_message", "Send a message to a Telegram chat using a bot", {
+  chatId: z2.string().describe("The Telegram chat ID to send the message to"),
+  message: z2.string().describe("The message text to send")
+}, async ({ chatId, message }) => {
+  const botToken = getTelegramBotToken();
+  const result = await sendTelegramMessage({ chatId, message, botToken });
+  if (!result.success) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Failed to send message`
+        }
+      ],
+      isError: true
+    };
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Message sent successfully! Message ID: ${result.data.messageId}`
+      }
+    ]
+  };
+});
+var transport = new StdioServerTransport;
+await server.connect(transport);

package/dist/oauth-store.d.ts

@@ -0,0 +1,17 @@
+export declare function createAuthorizationCode(params: {
+    userId: string;
+    codeChallenge: string;
+    redirectUri: string;
+}): string;
+export declare function consumeAuthorizationCode(code: string): {
+    userId: string;
+    codeChallenge: string;
+    redirectUri: string;
+} | null;
+export declare function createAccessToken(userId: string): {
+    token: string;
+    expiresIn: number;
+};
+export declare function validateAccessToken(token: string): {
+    userId: string;
+} | null;

package/dist/oauth-store.js

@@ -0,0 +1,85 @@
+// src/oauth-store.ts
+import { randomBytes } from "node:crypto";
+
+// src/db.ts
+import { Database } from "bun:sqlite";
+var db = new Database("sendkit.db", { create: true });
+db.exec("PRAGMA journal_mode = WAL;");
+db.exec(`
+  CREATE TABLE IF NOT EXISTS users (
+    id TEXT PRIMARY KEY,
+    username TEXT UNIQUE NOT NULL,
+    password_hash TEXT NOT NULL,
+    telegram_bot_token TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+`);
+db.exec(`
+  CREATE TABLE IF NOT EXISTS authorization_codes (
+    code TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    code_challenge TEXT NOT NULL,
+    redirect_uri TEXT NOT NULL,
+    expires_at INTEGER NOT NULL,
+    used INTEGER NOT NULL DEFAULT 0,
+    FOREIGN KEY (user_id) REFERENCES users(id)
+  );
+`);
+db.exec(`
+  CREATE TABLE IF NOT EXISTS access_tokens (
+    token TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    expires_at INTEGER NOT NULL,
+    FOREIGN KEY (user_id) REFERENCES users(id)
+  );
+`);
+
+// src/oauth-store.ts
+var AUTH_CODE_TTL_MS = 5 * 60 * 1000;
+var ACCESS_TOKEN_TTL_MS = 60 * 60 * 1000;
+function generateSecureToken() {
+  return randomBytes(32).toString("hex");
+}
+function createAuthorizationCode(params) {
+  const code = generateSecureToken();
+  const expiresAt = Date.now() + AUTH_CODE_TTL_MS;
+  db.query(`INSERT INTO authorization_codes (code, user_id, code_challenge, redirect_uri, expires_at)
+     VALUES (?, ?, ?, ?, ?)`).run(code, params.userId, params.codeChallenge, params.redirectUri, expiresAt);
+  return code;
+}
+function consumeAuthorizationCode(code) {
+  const row = db.query(`SELECT user_id, code_challenge, redirect_uri, expires_at, used
+       FROM authorization_codes WHERE code = ?`).get(code);
+  if (!row)
+    return null;
+  if (row.used)
+    return null;
+  if (Date.now() > row.expires_at)
+    return null;
+  db.query("UPDATE authorization_codes SET used = 1 WHERE code = ?").run(code);
+  return {
+    userId: row.user_id,
+    codeChallenge: row.code_challenge,
+    redirectUri: row.redirect_uri
+  };
+}
+function createAccessToken(userId) {
+  const token = generateSecureToken();
+  const expiresAt = Date.now() + ACCESS_TOKEN_TTL_MS;
+  db.query("INSERT INTO access_tokens (token, user_id, expires_at) VALUES (?, ?, ?)").run(token, userId, expiresAt);
+  return { token, expiresIn: ACCESS_TOKEN_TTL_MS / 1000 };
+}
+function validateAccessToken(token) {
+  const row = db.query("SELECT user_id, expires_at FROM access_tokens WHERE token = ?").get(token);
+  if (!row)
+    return null;
+  if (Date.now() > row.expires_at)
+    return null;
+  return { userId: row.user_id };
+}
+export {
+  validateAccessToken,
+  createAuthorizationCode,
+  createAccessToken,
+  consumeAuthorizationCode
+};

package/dist/pkce.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hashes a code_verifier the same way a spec-compliant client does,
+ * so we can compare it against the code_challenge stored earlier.
+ *
+ * Used in: /token endpoint, right before issuing an access token.
+ */
+export declare function verifyPkce(codeVerifier: string, storedCodeChallenge: string): Promise<boolean>;

package/dist/routes/auth.d.ts

@@ -0,0 +1,2 @@
+import { Hono } from "hono";
+export declare const authRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;