revxl-devtools 1.0.0

package/src/index.ts

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import {
+  checkProAccess,
+  getTrialUsesRemaining,
+  incrementTrialUse,
+} from "./auth.js";
+import {
+  registerTool,
+  getToolByName,
+  getAllTools,
+} from "./registry.js";
+import type { ToolDefinition } from "./registry.js";
+
+// Re-export for tool files that import from index
+export { registerTool, getToolByName, getAllTools };
+export type { ToolDefinition };
+
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+
+const PURCHASE_URL = "https://revxl-devtools.vercel.app";
+
+const server = new Server(
+  { name: "@revxl/devtools", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+
+// --- ListTools ------------------------------------------------------------
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  const toolList = getAllTools().map((t) => ({
+    name: t.name,
+    description: t.pro
+      ? `${t.description} [PRO - 3 free trials]`
+      : t.description,
+    inputSchema: t.inputSchema,
+  }));
+  return { tools: toolList };
+});
+
+// --- CallTool -------------------------------------------------------------
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  const tool = getToolByName(name);
+  if (!tool) {
+    return {
+      content: [{ type: "text", text: `Unknown tool: ${name}` }],
+      isError: true,
+    };
+  }
+
+  // Pro gate
+  if (tool.pro) {
+    const isPro = await checkProAccess();
+    if (!isPro) {
+      const remaining = getTrialUsesRemaining(name);
+      if (remaining <= 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `⚡ ${name} is a Pro tool and you've used all 3 free trials.\n\nUpgrade for $7 one-time at ${PURCHASE_URL} to unlock unlimited access to all Pro tools.`,
+            },
+          ],
+          isError: false,
+        };
+      }
+      incrementTrialUse(name);
+    }
+  }
+
+  try {
+    const result = await tool.handler((args ?? {}) as Record<string, unknown>);
+    const text =
+      typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    return { content: [{ type: "text", text }] };
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{ type: "text", text: `Error in ${name}: ${message}` }],
+      isError: true,
+    };
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Tool imports
+// ---------------------------------------------------------------------------
+
+// Free tools
+import "./tools/json-format.js";
+import "./tools/base64.js";
+import "./tools/url-encode.js";
+import "./tools/uuid.js";
+import "./tools/hash.js";
+import "./tools/timestamp.js";
+import "./tools/http-status.js";
+
+// Pro tools
+import "./tools/jwt.js";
+import "./tools/regex.js";
+import "./tools/cron.js";
+import "./tools/json-diff.js";
+import "./tools/json-query.js";
+import "./tools/batch.js";
+import "./tools/sql-format.js";
+import "./tools/yaml-convert.js";
+import "./tools/chmod.js";
+import "./tools/secrets-scan.js";
+
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("@revxl/devtools MCP server running on stdio");
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/src/registry.ts

@@ -0,0 +1,25 @@
+// ---------------------------------------------------------------------------
+// Tool registry — separated to avoid circular import issues with ESM hoisting
+// ---------------------------------------------------------------------------
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  pro: boolean;
+  inputSchema: Record<string, unknown>;
+  handler: (args: Record<string, unknown>) => Promise<unknown>;
+}
+
+const tools: Map<string, ToolDefinition> = new Map();
+
+export function registerTool(tool: ToolDefinition): void {
+  tools.set(tool.name, tool);
+}
+
+export function getToolByName(name: string): ToolDefinition | undefined {
+  return tools.get(name);
+}
+
+export function getAllTools(): ToolDefinition[] {
+  return Array.from(tools.values());
+}

package/src/tools/base64.ts

@@ -0,0 +1,32 @@
+import { registerTool } from "../registry.js";
+
+registerTool({
+  name: "base64",
+  description: "Encode or decode Base64 strings",
+  pro: false,
+  inputSchema: {
+    type: "object",
+    properties: {
+      text: { type: "string", description: "Text to encode or Base64 string to decode" },
+      action: {
+        type: "string",
+        enum: ["encode", "decode"],
+        description: "encode or decode",
+      },
+    },
+    required: ["text", "action"],
+  },
+  handler: async (args) => {
+    const text = args.text as string;
+    const action = args.action as string;
+
+    if (action === "encode") {
+      return Buffer.from(text, "utf-8").toString("base64");
+    }
+
+    // Handle URL-safe Base64 variant
+    const normalized = text.replace(/-/g, "+").replace(/_/g, "/");
+    const decoded = Buffer.from(normalized, "base64").toString("utf-8");
+    return decoded;
+  },
+});

package/src/tools/batch.ts

@@ -0,0 +1,69 @@
+import { registerTool, getToolByName } from "../registry.js";
+
+// ---------------------------------------------------------------------------
+// Batch runner — execute a free tool across multiple inputs
+// ---------------------------------------------------------------------------
+
+const MAX_ITEMS = 500;
+
+registerTool({
+  name: "batch",
+  description:
+    "Run any free tool across multiple inputs in one call — up to 500 items. Only works with free (non-Pro) tools.",
+  pro: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      tool: {
+        type: "string",
+        description: "Name of the tool to run (must be a free tool)",
+      },
+      items: {
+        type: "array",
+        items: { type: "object" },
+        description: "Array of argument objects — each is passed to the tool's handler (max 500)",
+      },
+    },
+    required: ["tool", "items"],
+  },
+  handler: async (args) => {
+    const toolName = args.tool as string;
+    const items = args.items as Record<string, unknown>[];
+
+    if (!Array.isArray(items) || items.length === 0) {
+      throw new Error("items must be a non-empty array");
+    }
+
+    if (items.length > MAX_ITEMS) {
+      throw new Error(`Maximum ${MAX_ITEMS} items per batch (got ${items.length})`);
+    }
+
+    const tool = getToolByName(toolName);
+    if (!tool) {
+      throw new Error(`Unknown tool: ${toolName}`);
+    }
+
+    if (tool.pro) {
+      throw new Error(
+        `Batch only works with free tools. "${toolName}" is a Pro tool.`,
+      );
+    }
+
+    const results: string[] = [];
+
+    for (let i = 0; i < items.length; i++) {
+      try {
+        const result = await tool.handler(items[i]);
+        const text =
+          typeof result === "string" ? result : JSON.stringify(result, null, 2);
+        results.push(`[${i}] ${text}`);
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        results.push(`[${i}] ERROR: ${message}`);
+      }
+    }
+
+    const header = `Batch ${toolName}: ${items.length} items`;
+    return `${header}\n${"=".repeat(header.length)}\n\n${results.join("\n\n")}`;
+  },
+});

package/src/tools/chmod.ts

@@ -0,0 +1,133 @@
+import { registerTool } from "../registry.js";
+
+// ---------------------------------------------------------------------------
+// Chmod converter — numeric ↔ symbolic with human-readable explanation
+// ---------------------------------------------------------------------------
+
+const PERM_MAP: Record<number, string> = {
+  0: "---",
+  1: "--x",
+  2: "-w-",
+  3: "-wx",
+  4: "r--",
+  5: "r-x",
+  6: "rw-",
+  7: "rwx",
+};
+
+const ROLE_NAMES = ["Owner", "Group", "Others"] as const;
+
+const PERM_LABELS: Record<string, string> = {
+  r: "read",
+  w: "write",
+  x: "execute",
+};
+
+function numericToSymbolic(mode: string): string {
+  const digits = mode.split("").map(Number);
+  return digits.map((d) => PERM_MAP[d]).join("");
+}
+
+function symbolicToNumeric(mode: string): string {
+  // Expect 9-char symbolic like "rwxr-xr-x"
+  const clean = mode.replace(/^-/, ""); // strip leading - if present (like -rwxr-xr-x)
+  const chars = clean.length >= 9 ? clean.slice(0, 9) : clean;
+  let result = "";
+  for (let i = 0; i < 3; i++) {
+    const group = chars.slice(i * 3, i * 3 + 3);
+    let val = 0;
+    if (group[0] === "r") val += 4;
+    if (group[1] === "w") val += 2;
+    if (group[2] === "x") val += 1;
+    result += val;
+  }
+  return result;
+}
+
+function describePermissions(numericMode: string): string[] {
+  const digits = numericMode.split("").map(Number);
+  const descriptions: string[] = [];
+
+  for (let i = 0; i < 3; i++) {
+    const symbolic = PERM_MAP[digits[i]];
+    const perms: string[] = [];
+    for (const ch of symbolic) {
+      if (ch !== "-" && PERM_LABELS[ch]) {
+        perms.push(PERM_LABELS[ch]);
+      }
+    }
+    const permStr = perms.length > 0 ? perms.join(", ") : "none";
+    descriptions.push(`${ROLE_NAMES[i]}: ${permStr}`);
+  }
+
+  return descriptions;
+}
+
+function isNumericMode(mode: string): boolean {
+  return /^[0-7]{3,4}$/.test(mode);
+}
+
+function isSymbolicMode(mode: string): boolean {
+  // Accept rwxr-xr-x or -rwxr-xr-x
+  return /^-?[rwx-]{9}$/.test(mode);
+}
+
+registerTool({
+  name: "chmod",
+  description:
+    "Convert between numeric (755) and symbolic (rwxr-xr-x) chmod permissions with explanation",
+  pro: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      mode: {
+        type: "string",
+        description:
+          'Permission mode — numeric (e.g. "755") or symbolic (e.g. "rwxr-xr-x")',
+      },
+    },
+    required: ["mode"],
+  },
+  handler: async (args) => {
+    const mode = (args.mode as string).trim();
+
+    if (!mode) throw new Error("mode is required");
+
+    if (isNumericMode(mode)) {
+      // Take last 3 digits (ignore leading 0 in 0755)
+      const digits = mode.slice(-3);
+      const symbolic = numericToSymbolic(digits);
+      const explanation = describePermissions(digits);
+
+      return [
+        "=== Chmod: Numeric → Symbolic ===",
+        "",
+        `Numeric:  ${digits}`,
+        `Symbolic: ${symbolic}`,
+        "",
+        "--- Permissions ---",
+        ...explanation.map((e) => `  ${e}`),
+      ].join("\n");
+    }
+
+    if (isSymbolicMode(mode)) {
+      const clean = mode.startsWith("-") ? mode.slice(1) : mode;
+      const numeric = symbolicToNumeric(clean);
+      const explanation = describePermissions(numeric);
+
+      return [
+        "=== Chmod: Symbolic → Numeric ===",
+        "",
+        `Symbolic: ${clean}`,
+        `Numeric:  ${numeric}`,
+        "",
+        "--- Permissions ---",
+        ...explanation.map((e) => `  ${e}`),
+      ].join("\n");
+    }
+
+    throw new Error(
+      `Invalid mode: "${mode}". Use numeric (e.g. "755") or symbolic (e.g. "rwxr-xr-x").`,
+    );
+  },
+});