@hasna/skills 0.0.2

package/skills/skill-sms/src/server.ts

@@ -0,0 +1,351 @@
+#!/usr/bin/env bun
+/**
+ * MCP SMS HTTP Server
+ * Provides SMS functionality for AI agents via HTTP API using Twilio
+ */
+
+import twilio from "twilio";
+
+// Configuration
+const CONFIG = {
+  port: parseInt(process.env.PORT || "3848"),
+  accountSid: process.env.TWILIO_ACCOUNT_SID || "",
+  authToken: process.env.TWILIO_AUTH_TOKEN || "",
+  apiKey: process.env.MCP_SMS_API_KEY || "",
+};
+
+// Twilio Client
+const twilioClient = twilio(CONFIG.accountSid, CONFIG.authToken);
+
+// Helper: Capitalize first letter
+function capitalize(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+
+// Helper: Get display name for agent - "[Name] (AI Agent)"
+function getDisplayName(agentName: string): string {
+  return `${capitalize(agentName)} (AI Agent)`;
+}
+
+// Helper: Validate API key
+function validateApiKey(request: Request): boolean {
+  if (!CONFIG.apiKey) return true;
+  const authHeader = request.headers.get("Authorization");
+  if (!authHeader) return false;
+  const [type, key] = authHeader.split(" ");
+  return type === "Bearer" && key === CONFIG.apiKey;
+}
+
+// Helper: JSON response
+function jsonResponse(data: any, status = 200): Response {
+  return new Response(JSON.stringify(data, null, 2), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+// Helper: Error response
+function errorResponse(message: string, status = 400): Response {
+  return jsonResponse({ success: false, error: message }, status);
+}
+
+// Helper: Format phone number to E.164
+function formatPhoneNumber(phone: string): string {
+  const digits = phone.replace(/\D/g, "");
+  if (digits.length === 10) {
+    return `+1${digits}`;
+  }
+  if (digits.length === 11 && digits.startsWith("1")) {
+    return `+${digits}`;
+  }
+  if (!phone.startsWith("+")) {
+    return `+${digits}`;
+  }
+  return phone;
+}
+
+// Send SMS
+async function sendSms(params: {
+  agent_name: string;
+  from_number: string;
+  to: string;
+  body: string;
+}): Promise<{ success: boolean; message_sid?: string; error?: string }> {
+  try {
+    const message = await twilioClient.messages.create({
+      body: params.body,
+      from: formatPhoneNumber(params.from_number),
+      to: formatPhoneNumber(params.to),
+    });
+
+    return {
+      success: true,
+      message_sid: message.sid,
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
+
+// List messages
+async function listMessages(params: {
+  agent_name: string;
+  phone_number: string;
+  limit?: number;
+  direction?: "inbound" | "outbound";
+}): Promise<any> {
+  try {
+    const options: any = {
+      limit: params.limit || 20,
+    };
+
+    if (params.direction === "inbound") {
+      options.to = formatPhoneNumber(params.phone_number);
+    } else if (params.direction === "outbound") {
+      options.from = formatPhoneNumber(params.phone_number);
+    }
+
+    const messages = await twilioClient.messages.list(options);
+
+    return {
+      success: true,
+      count: messages.length,
+      messages: messages.map((m) => ({
+        sid: m.sid,
+        from: m.from,
+        to: m.to,
+        body: m.body,
+        status: m.status,
+        direction: m.direction,
+        date_sent: m.dateSent?.toISOString(),
+        date_created: m.dateCreated?.toISOString(),
+      })),
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
+
+// Get message
+async function getMessage(messageSid: string): Promise<any> {
+  try {
+    const message = await twilioClient.messages(messageSid).fetch();
+
+    return {
+      success: true,
+      sid: message.sid,
+      from: message.from,
+      to: message.to,
+      body: message.body,
+      status: message.status,
+      direction: message.direction,
+      date_sent: message.dateSent?.toISOString(),
+      date_created: message.dateCreated?.toISOString(),
+      price: message.price,
+      price_unit: message.priceUnit,
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
+
+// List phone numbers
+async function listPhoneNumbers(): Promise<any> {
+  try {
+    const numbers = await twilioClient.incomingPhoneNumbers.list();
+
+    return {
+      success: true,
+      count: numbers.length,
+      phone_numbers: numbers.map((n) => ({
+        sid: n.sid,
+        phone_number: n.phoneNumber,
+        friendly_name: n.friendlyName,
+        capabilities: n.capabilities,
+        date_created: n.dateCreated?.toISOString(),
+      })),
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
+
+// Buy phone number
+async function buyPhoneNumber(params: {
+  area_code?: string;
+  friendly_name?: string;
+}): Promise<any> {
+  try {
+    // Search for available numbers
+    const searchOptions: any = {
+      limit: 1,
+    };
+
+    if (params.area_code) {
+      searchOptions.areaCode = params.area_code;
+    }
+
+    const availableNumbers =
+      await twilioClient.availablePhoneNumbers("US").local.list(searchOptions);
+
+    if (availableNumbers.length === 0) {
+      return {
+        success: false,
+        error: "No available phone numbers found",
+      };
+    }
+
+    // Purchase the number
+    const purchased = await twilioClient.incomingPhoneNumbers.create({
+      phoneNumber: availableNumbers[0].phoneNumber,
+      friendlyName: params.friendly_name || "MCP SMS Agent",
+    });
+
+    return {
+      success: true,
+      phone_number: purchased.phoneNumber,
+      sid: purchased.sid,
+      friendly_name: purchased.friendlyName,
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
+
+// HTTP Server
+const PATH_PREFIX = "/sms";
+
+const server = Bun.serve({
+  port: CONFIG.port,
+  async fetch(request) {
+    const url = new URL(request.url);
+    let path = url.pathname;
+    const method = request.method;
+
+    // Strip path prefix if present (for ALB routing)
+    if (path.startsWith(PATH_PREFIX)) {
+      path = path.slice(PATH_PREFIX.length) || "/";
+    }
+
+    // Health check
+    if (path === "/health" && method === "GET") {
+      return jsonResponse({ status: "ok", version: "1.0.0" });
+    }
+
+    // API key validation for all other routes
+    if (!validateApiKey(request)) {
+      return errorResponse("Unauthorized", 401);
+    }
+
+    try {
+      // POST /send - Send SMS
+      if (path === "/send" && method === "POST") {
+        const body = await request.json();
+
+        if (!body.agent_name || !body.from_number || !body.to || !body.body) {
+          return errorResponse(
+            "Missing required fields: agent_name, from_number, to, body"
+          );
+        }
+
+        const result = await sendSms(body);
+        return jsonResponse({
+          ...result,
+          agent: getDisplayName(body.agent_name),
+          from: formatPhoneNumber(body.from_number),
+          to: formatPhoneNumber(body.to),
+        });
+      }
+
+      // GET /messages/:phone - List messages for a phone number
+      if (path.startsWith("/messages/") && method === "GET") {
+        const parts = path.split("/");
+        const phoneNumber = decodeURIComponent(parts[2]);
+        const agentName = url.searchParams.get("agent") || "unknown";
+        const limit = parseInt(url.searchParams.get("limit") || "20");
+        const direction = url.searchParams.get("direction") as
+          | "inbound"
+          | "outbound"
+          | undefined;
+
+        if (!phoneNumber) {
+          return errorResponse("Phone number required");
+        }
+
+        const result = await listMessages({
+          agent_name: agentName,
+          phone_number: phoneNumber,
+          limit,
+          direction,
+        });
+        return jsonResponse(result);
+      }
+
+      // GET /message/:sid - Get specific message
+      if (path.startsWith("/message/") && method === "GET") {
+        const messageSid = path.split("/")[2];
+
+        if (!messageSid) {
+          return errorResponse("Message SID required");
+        }
+
+        const result = await getMessage(messageSid);
+        return jsonResponse(result);
+      }
+
+      // GET /numbers - List phone numbers
+      if (path === "/numbers" && method === "GET") {
+        const result = await listPhoneNumbers();
+        return jsonResponse(result);
+      }
+
+      // POST /numbers/buy - Buy a phone number
+      if (path === "/numbers/buy" && method === "POST") {
+        const body = await request.json();
+        const result = await buyPhoneNumber({
+          area_code: body.area_code,
+          friendly_name: body.friendly_name,
+        });
+        return jsonResponse(result);
+      }
+
+      // GET /agent/:name - Get agent info
+      if (path.startsWith("/agent/") && method === "GET") {
+        const agentName = path.split("/")[2];
+
+        if (!agentName) {
+          return errorResponse("Agent name required");
+        }
+
+        return jsonResponse({
+          success: true,
+          agent_name: agentName,
+          display_name: getDisplayName(agentName),
+        });
+      }
+
+      return errorResponse("Not found", 404);
+    } catch (error: any) {
+      console.error("Error:", error);
+      return errorResponse(error.message, 500);
+    }
+  },
+});
+
+console.log(`MCP SMS Server running on http://localhost:${CONFIG.port}`);
+console.log(`API Key: ${CONFIG.apiKey ? "configured" : "not configured (open access)"}`);

package/skills/skill-sms/src/sse-server.ts

@@ -0,0 +1,279 @@
+#!/usr/bin/env bun
+/**
+ * MCP SMS SSE Server
+ * Provides SMS functionality for AI agents via SSE transport using Twilio
+ */
+
+import express from "express";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { z } from "zod";
+import twilio from "twilio";
+
+// Configuration
+const CONFIG = {
+  port: parseInt(process.env.PORT || "3848"),
+  accountSid: process.env.TWILIO_ACCOUNT_SID || "",
+  authToken: process.env.TWILIO_AUTH_TOKEN || "",
+  apiKey: process.env.MCP_SMS_API_KEY || "",
+};
+
+// Twilio Client
+const twilioClient = twilio(CONFIG.accountSid, CONFIG.authToken);
+
+// Helper functions
+function capitalize(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+
+function getDisplayName(agentName: string): string {
+  return `${capitalize(agentName)} (AI Agent)`;
+}
+
+function formatPhoneNumber(phone: string): string {
+  const digits = phone.replace(/\D/g, "");
+  if (digits.length === 10) return `+1${digits}`;
+  if (digits.length === 11 && digits.startsWith("1")) return `+${digits}`;
+  if (!phone.startsWith("+")) return `+${digits}`;
+  return phone;
+}
+
+// Create MCP Server with tools
+function createMcpServer(): McpServer {
+  const server = new McpServer({
+    name: "mcp-sms",
+    version: "1.0.0",
+  });
+
+  // Tool: Send SMS
+  server.tool(
+    "send_sms",
+    "Send an SMS message from an AI agent",
+    {
+      agent_name: z.string().describe("Name of the AI agent sending the SMS"),
+      from_number: z.string().describe("Twilio phone number to send from"),
+      to: z.string().describe("Recipient phone number"),
+      body: z.string().describe("SMS message body (max 1600 characters)"),
+    },
+    async ({ agent_name, from_number, to, body }) => {
+      try {
+        const message = await twilioClient.messages.create({
+          body,
+          from: formatPhoneNumber(from_number),
+          to: formatPhoneNumber(to),
+        });
+
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              message_sid: message.sid,
+              agent: getDisplayName(agent_name),
+              from: formatPhoneNumber(from_number),
+              to: formatPhoneNumber(to),
+              status: message.status,
+            }, null, 2),
+          }],
+        };
+      } catch (error: any) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: false, error: error.message }, null, 2) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Tool: List Messages
+  server.tool(
+    "list_messages",
+    "List SMS messages for a phone number",
+    {
+      agent_name: z.string().describe("Name of the AI agent"),
+      phone_number: z.string().describe("Phone number to list messages for"),
+      limit: z.number().optional().default(20).describe("Maximum number of messages"),
+      direction: z.enum(["inbound", "outbound"]).optional().describe("Filter by message direction"),
+    },
+    async ({ agent_name, phone_number, limit, direction }) => {
+      try {
+        const options: any = { limit };
+        if (direction === "inbound") options.to = formatPhoneNumber(phone_number);
+        else if (direction === "outbound") options.from = formatPhoneNumber(phone_number);
+
+        const messages = await twilioClient.messages.list(options);
+
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              agent: getDisplayName(agent_name),
+              count: messages.length,
+              messages: messages.map((m) => ({
+                sid: m.sid,
+                from: m.from,
+                to: m.to,
+                body: m.body,
+                status: m.status,
+                direction: m.direction,
+                date_sent: m.dateSent?.toISOString(),
+              })),
+            }, null, 2),
+          }],
+        };
+      } catch (error: any) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: false, error: error.message }, null, 2) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Tool: Read Message
+  server.tool(
+    "read_message",
+    "Read a specific SMS message by SID",
+    {
+      message_sid: z.string().describe("The Twilio message SID"),
+    },
+    async ({ message_sid }) => {
+      try {
+        const message = await twilioClient.messages(message_sid).fetch();
+
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              sid: message.sid,
+              from: message.from,
+              to: message.to,
+              body: message.body,
+              status: message.status,
+              direction: message.direction,
+              date_sent: message.dateSent?.toISOString(),
+              date_created: message.dateCreated?.toISOString(),
+              price: message.price,
+              price_unit: message.priceUnit,
+            }, null, 2),
+          }],
+        };
+      } catch (error: any) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: false, error: error.message }, null, 2) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Tool: List Phone Numbers
+  server.tool(
+    "list_phone_numbers",
+    "List all Twilio phone numbers in the account",
+    {},
+    async () => {
+      try {
+        const numbers = await twilioClient.incomingPhoneNumbers.list();
+
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              count: numbers.length,
+              phone_numbers: numbers.map((n) => ({
+                sid: n.sid,
+                phone_number: n.phoneNumber,
+                friendly_name: n.friendlyName,
+                capabilities: n.capabilities,
+              })),
+            }, null, 2),
+          }],
+        };
+      } catch (error: any) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: false, error: error.message }, null, 2) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Tool: Get Agent Info
+  server.tool(
+    "get_agent_info",
+    "Get SMS configuration info for an AI agent",
+    {
+      agent_name: z.string().describe("Name of the AI agent"),
+    },
+    async ({ agent_name }) => {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            agent_name,
+            display_name: getDisplayName(agent_name),
+          }, null, 2),
+        }],
+      };
+    }
+  );
+
+  return server;
+}
+
+// Validate API key middleware
+function validateApiKey(req: express.Request, res: express.Response, next: express.NextFunction) {
+  if (!CONFIG.apiKey) return next();
+  const authHeader = req.headers.authorization;
+  if (!authHeader) return res.status(401).json({ error: "Unauthorized" });
+  const [type, key] = authHeader.split(" ");
+  if (type !== "Bearer" || key !== CONFIG.apiKey) return res.status(401).json({ error: "Unauthorized" });
+  next();
+}
+
+// Express app
+const app = express();
+// Don't use express.json() globally - SSEServerTransport needs raw stream
+// app.use(express.json());
+
+const transports: { [sessionId: string]: SSEServerTransport } = {};
+
+app.get("/health", (req, res) => {
+  res.json({ status: "ok", version: "1.0.0", transport: "sse" });
+});
+
+app.get("/sse", validateApiKey, async (req, res) => {
+  console.log("SSE connection request received");
+  const transport = new SSEServerTransport("/mcp/sms/messages", res);
+  transports[transport.sessionId] = transport;
+  console.log("SSE session started:", transport.sessionId);
+  
+  res.on("close", () => {
+    console.log("SSE session closed:", transport.sessionId);
+    delete transports[transport.sessionId];
+  });
+  
+  const server = createMcpServer();
+  await server.connect(transport);
+});
+
+app.post("/messages", validateApiKey, async (req, res) => {
+  const sessionId = req.query.sessionId as string;
+  const transport = transports[sessionId];
+  
+  if (transport) {
+    await transport.handlePostMessage(req, res);
+  } else {
+    res.status(400).json({ error: "No transport found for sessionId" });
+  }
+});
+
+app.listen(CONFIG.port, () => {
+  console.log(`MCP SMS SSE Server running on http://localhost:${CONFIG.port}`);
+  console.log(`SSE endpoint: http://localhost:${CONFIG.port}/sse`);
+  console.log(`API Key: ${CONFIG.apiKey ? "configured" : "not configured"}`);
+});

package/skills/skill-sms/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "noUncheckedIndexedAccess": true,
+    "noEmit": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*", "scripts/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/skills/skill-social-media-kit/CLAUDE.md

@@ -0,0 +1,19 @@
+# skill-social-media-kit
+
+Social Media Kit skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+skill-social-media-kit run
+```
+
+## Data Directory
+
+~/.skill/skill-social-media-kit/

package/skills/skill-social-media-kit/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@hasnaxyz/skill-social-media-kit",
+  "version": "0.1.0",
+  "description": "Social Media Kit skill",
+  "type": "module",
+  "bin": {
+    "skill-social-media-kit": "./bin/cli.ts"
+  },
+  "scripts": {
+    "dev": "bun run bin/cli.ts",
+    "build": "bun build bin/cli.ts --outdir dist --target node",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": ["bin", "src", "tsconfig.json"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/skill-social-media-kit.git"
+  },
+  "author": "Hasna",
+  "license": "MIT"
+}