revxl-devtools 1.0.2 → 1.0.3

package/src/auth.ts

@@ -1,99 +0,0 @@
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-const CACHE_PATH = join(homedir(), ".revxl-devtools-cache.json");
-const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
-const MAX_TRIAL_USES = 3;
-
-interface Cache {
-  proValidated: boolean;
-  validatedAt: number;
-  trialUses: Record<string, number>;
-}
-
-function loadCache(): Cache {
-  try {
-    const raw = readFileSync(CACHE_PATH, "utf-8");
-    return JSON.parse(raw) as Cache;
-  } catch {
-    return { proValidated: false, validatedAt: 0, trialUses: {} };
-  }
-}
-
-function saveCache(cache: Cache): void {
-  try {
-    writeFileSync(CACHE_PATH, JSON.stringify(cache, null, 2), "utf-8");
-  } catch {
-    // Silently fail — cache is best-effort
-  }
-}
-
-async function validateKeyWithSupabase(key: string): Promise<boolean> {
-  const supabaseUrl = process.env.SUPABASE_URL;
-  const supabaseAnonKey = process.env.SUPABASE_ANON_KEY;
-
-  if (!supabaseUrl || !supabaseAnonKey) {
-    // Dev mode: accept any RX-prefixed key
-    return key.startsWith("RX.");
-  }
-
-  try {
-    const res = await fetch(
-      `${supabaseUrl}/rest/v1/pro_keys?key=eq.${encodeURIComponent(key)}&select=active`,
-      {
-        headers: {
-          apikey: supabaseAnonKey,
-          Authorization: `Bearer ${supabaseAnonKey}`,
-        },
-      }
-    );
-
-    if (!res.ok) {
-      // Supabase down — fall back to format check
-      return key.startsWith("RX.");
-    }
-
-    const rows = (await res.json()) as Array<{ active: boolean }>;
-    return rows.length > 0 && rows[0].active === true;
-  } catch {
-    // Network error — fall back to format check
-    return key.startsWith("RX.");
-  }
-}
-
-export async function checkProAccess(): Promise<boolean> {
-  const key = process.env.MCP_DEVTOOLS_KEY;
-  if (!key || !key.startsWith("RX.")) {
-    return false;
-  }
-
-  const cache = loadCache();
-
-  // Check cache validity
-  const cacheAge = Date.now() - cache.validatedAt;
-  if (cache.proValidated && cacheAge < CACHE_TTL_MS) {
-    return true;
-  }
-
-  // Validate against Supabase (or dev mode fallback)
-  const valid = await validateKeyWithSupabase(key);
-
-  cache.proValidated = valid;
-  cache.validatedAt = Date.now();
-  saveCache(cache);
-
-  return valid;
-}
-
-export function getTrialUsesRemaining(toolName: string): number {
-  const cache = loadCache();
-  const used = cache.trialUses[toolName] ?? 0;
-  return Math.max(0, MAX_TRIAL_USES - used);
-}
-
-export function incrementTrialUse(toolName: string): void {
-  const cache = loadCache();
-  cache.trialUses[toolName] = (cache.trialUses[toolName] ?? 0) + 1;
-  saveCache(cache);
-}

package/src/codegen/cron-codegen.ts

@@ -1,66 +0,0 @@
-// ---------------------------------------------------------------------------
-// Cron code generation — crontab, systemd timer, and node-cron snippets
-// ---------------------------------------------------------------------------
-
-export function generateCronCode(expression: string): string {
-  const crontab = `# Crontab entry
-${expression} /path/to/command`;
-
-  const systemd = generateSystemdTimer(expression);
-  const nodeCron = generateNodeCron(expression);
-
-  return [crontab, systemd, nodeCron].join("\n\n---\n\n");
-}
-
-function cronToOnCalendar(expression: string): string {
-  const parts = expression.split(/\s+/);
-  if (parts.length !== 5) return expression;
-
-  const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
-
-  const dayMap: Record<string, string> = {
-    "0": "Sun", "1": "Mon", "2": "Tue", "3": "Wed",
-    "4": "Thu", "5": "Fri", "6": "Sat", "7": "Sun",
-  };
-
-  let dow = "*";
-  if (dayOfWeek !== "*") {
-    dow = dayOfWeek
-      .split(",")
-      .map((d) => dayMap[d] || d)
-      .join(",");
-  }
-
-  const dom = dayOfMonth === "*" ? "*" : dayOfMonth;
-  const mon = month === "*" ? "*" : month.padStart(2, "0");
-  const h = hour === "*" ? "*" : hour.padStart(2, "0");
-  const m = minute === "*" ? "*" : minute.padStart(2, "0");
-
-  return `${dow} *-${mon}-${dom} ${h}:${m}:00`;
-}
-
-function generateSystemdTimer(expression: string): string {
-  const onCalendar = cronToOnCalendar(expression);
-  return `# systemd timer unit — save as /etc/systemd/system/mytask.timer
-[Unit]
-Description=My scheduled task
-
-[Timer]
-OnCalendar=${onCalendar}
-Persistent=true
-
-[Install]
-WantedBy=timers.target`;
-}
-
-function generateNodeCron(expression: string): string {
-  return `// Node.js — npm install cron
-import { CronJob } from 'cron';
-
-const job = new CronJob('${expression}', () => {
-  console.log('Task executed at', new Date().toISOString());
-  // your logic here
-});
-
-job.start();`;
-}

package/src/codegen/regex-codegen.ts

@@ -1,132 +0,0 @@
-// ---------------------------------------------------------------------------
-// Regex code generation — produces working snippets in 5 languages
-// ---------------------------------------------------------------------------
-
-type Language = "javascript" | "python" | "go" | "rust" | "java";
-
-const ALL_LANGUAGES: Language[] = ["javascript", "python", "go", "rust", "java"];
-
-function jsFlags(flags: string): string {
-  return flags || "";
-}
-
-function pyFlags(flags: string): string {
-  const parts: string[] = [];
-  if (flags.includes("i")) parts.push("re.IGNORECASE");
-  if (flags.includes("m")) parts.push("re.MULTILINE");
-  if (flags.includes("s")) parts.push("re.DOTALL");
-  return parts.length ? ", " + parts.join(" | ") : "";
-}
-
-function generateJS(pattern: string, flags: string): string {
-  const f = jsFlags(flags);
-  return `// JavaScript
-const regex = /${pattern}/${f};
-const text = "your text here";
-
-const matches = text.match(regex);
-if (matches) {
-  console.log("Matches:", matches);
-} else {
-  console.log("No matches found");
-}`;
-}
-
-function generatePython(pattern: string, flags: string): string {
-  const f = pyFlags(flags);
-  return `# Python
-import re
-
-pattern = re.compile(r'${pattern}'${f})
-text = "your text here"
-
-matches = pattern.findall(text)
-print("Matches:", matches)`;
-}
-
-function generateGo(pattern: string, flags: string): string {
-  // Go uses inline flags (?i) etc.
-  let goFlags = "";
-  if (flags.includes("i")) goFlags += "i";
-  if (flags.includes("m")) goFlags += "m";
-  if (flags.includes("s")) goFlags += "s";
-  const prefix = goFlags ? `(?${goFlags})` : "";
-  return `// Go
-package main
-
-import (
-\t"fmt"
-\t"regexp"
-)
-
-func main() {
-\tre := regexp.MustCompile(\`${prefix}${pattern}\`)
-\ttext := "your text here"
-
-\tmatches := re.FindAllString(text, -1)
-\tfmt.Println("Matches:", matches)
-}`;
-}
-
-function generateRust(pattern: string, flags: string): string {
-  let rustFlags = "";
-  if (flags.includes("i")) rustFlags += "(?i)";
-  if (flags.includes("m")) rustFlags += "(?m)";
-  if (flags.includes("s")) rustFlags += "(?s)";
-  return `// Rust — add \`regex = "1"\` to Cargo.toml [dependencies]
-use regex::Regex;
-
-fn main() {
-    let re = Regex::new(r"${rustFlags}${pattern}").unwrap();
-    let text = "your text here";
-
-    for m in re.find_iter(text) {
-        println!("Match: {}", m.as_str());
-    }
-}`;
-}
-
-function generateJava(pattern: string, flags: string): string {
-  const javaFlags: string[] = [];
-  if (flags.includes("i")) javaFlags.push("Pattern.CASE_INSENSITIVE");
-  if (flags.includes("m")) javaFlags.push("Pattern.MULTILINE");
-  if (flags.includes("s")) javaFlags.push("Pattern.DOTALL");
-  const flagArg = javaFlags.length ? ", " + javaFlags.join(" | ") : "";
-  return `// Java
-import java.util.regex.Pattern;
-import java.util.regex.Matcher;
-
-public class RegexDemo {
-    public static void main(String[] args) {
-        Pattern pattern = Pattern.compile("${pattern}"${flagArg});
-        String text = "your text here";
-        Matcher matcher = pattern.matcher(text);
-
-        while (matcher.find()) {
-            System.out.println("Match: " + matcher.group());
-        }
-    }
-}`;
-}
-
-const generators: Record<Language, (pattern: string, flags: string) => string> = {
-  javascript: generateJS,
-  python: generatePython,
-  go: generateGo,
-  rust: generateRust,
-  java: generateJava,
-};
-
-export function generateRegexCode(
-  pattern: string,
-  flags: string,
-  languages?: string[],
-): string {
-  const langs: Language[] = languages && languages.length
-    ? (languages.map((l) => l.toLowerCase()) as Language[]).filter(
-        (l) => l in generators,
-      )
-    : ALL_LANGUAGES;
-
-  return langs.map((lang) => generators[lang](pattern, flags)).join("\n\n---\n\n");
-}

package/src/index.ts

@@ -1,134 +0,0 @@
-#!/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://buy.stripe.com/28E14pfy1g5X1nz9HHgbm0s";
-
-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

@@ -1,25 +0,0 @@
-// ---------------------------------------------------------------------------
-// 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

@@ -1,32 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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").`,
-    );
-  },
-});