revxl-devtools 1.0.0

package/dist/tools/yaml-convert.js

@@ -0,0 +1,371 @@
+import { registerTool } from "../registry.js";
+// ---------------------------------------------------------------------------
+// Minimal YAML parser
+// ---------------------------------------------------------------------------
+function parseYaml(text) {
+    const lines = text.split("\n");
+    return parseYamlLines(lines, 0, 0).value;
+}
+function getIndent(line) {
+    const match = line.match(/^(\s*)/);
+    return match ? match[1].length : 0;
+}
+function parseScalar(val) {
+    const trimmed = val.trim();
+    if (trimmed === "" || trimmed === "null" || trimmed === "~")
+        return null;
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    if (/^-?\d+$/.test(trimmed))
+        return parseInt(trimmed, 10);
+    if (/^-?\d+\.\d+$/.test(trimmed))
+        return parseFloat(trimmed);
+    // Strip quotes
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function parseYamlLines(lines, startLine, baseIndent) {
+    // Skip empty lines and comments
+    let i = startLine;
+    while (i < lines.length && (lines[i].trim() === "" || lines[i].trim().startsWith("#"))) {
+        i++;
+    }
+    if (i >= lines.length)
+        return { value: null, nextLine: i };
+    const line = lines[i];
+    const trimmed = line.trim();
+    // Check if it's a list item
+    if (trimmed.startsWith("- ")) {
+        const arr = [];
+        const listIndent = getIndent(line);
+        while (i < lines.length) {
+            const cur = lines[i];
+            if (cur.trim() === "" || cur.trim().startsWith("#")) {
+                i++;
+                continue;
+            }
+            const curIndent = getIndent(cur);
+            if (curIndent < listIndent)
+                break;
+            if (curIndent === listIndent && cur.trim().startsWith("- ")) {
+                const itemText = cur.trim().slice(2);
+                // Check if it's a key: value (nested map in list)
+                if (itemText.includes(": ")) {
+                    const obj = {};
+                    const colonIdx = itemText.indexOf(": ");
+                    const key = itemText.slice(0, colonIdx).trim();
+                    const val = itemText.slice(colonIdx + 2).trim();
+                    obj[key] = parseScalar(val);
+                    // Check for continuation lines at deeper indent
+                    i++;
+                    while (i < lines.length) {
+                        const nextLine = lines[i];
+                        if (nextLine.trim() === "" || nextLine.trim().startsWith("#")) {
+                            i++;
+                            continue;
+                        }
+                        const nextIndent = getIndent(nextLine);
+                        if (nextIndent <= listIndent)
+                            break;
+                        if (nextLine.trim().includes(": ")) {
+                            const ci = nextLine.trim().indexOf(": ");
+                            const k = nextLine.trim().slice(0, ci).trim();
+                            const v = nextLine.trim().slice(ci + 2).trim();
+                            obj[k] = parseScalar(v);
+                            i++;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    arr.push(obj);
+                }
+                else {
+                    arr.push(parseScalar(itemText));
+                    i++;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        return { value: arr, nextLine: i };
+    }
+    // Check if it's a map (key: value)
+    if (trimmed.includes(": ") || trimmed.endsWith(":")) {
+        const obj = {};
+        const mapIndent = getIndent(line);
+        while (i < lines.length) {
+            const cur = lines[i];
+            if (cur.trim() === "" || cur.trim().startsWith("#")) {
+                i++;
+                continue;
+            }
+            const curIndent = getIndent(cur);
+            if (curIndent < mapIndent && i > startLine)
+                break;
+            if (curIndent !== mapIndent)
+                break;
+            const curTrimmed = cur.trim();
+            if (curTrimmed.endsWith(":")) {
+                // Block value — next lines are the value
+                const key = curTrimmed.slice(0, -1).trim();
+                i++;
+                const result = parseYamlLines(lines, i, mapIndent + 2);
+                obj[key] = result.value;
+                i = result.nextLine;
+            }
+            else if (curTrimmed.includes(": ")) {
+                const colonIdx = curTrimmed.indexOf(": ");
+                const key = curTrimmed.slice(0, colonIdx).trim();
+                const val = curTrimmed.slice(colonIdx + 2).trim();
+                obj[key] = parseScalar(val);
+                i++;
+            }
+            else {
+                break;
+            }
+        }
+        return { value: obj, nextLine: i };
+    }
+    // Plain scalar
+    return { value: parseScalar(trimmed), nextLine: i + 1 };
+}
+// ---------------------------------------------------------------------------
+// Minimal TOML parser
+// ---------------------------------------------------------------------------
+function parseToml(text) {
+    const result = {};
+    let currentSection = result;
+    const lines = text.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        // Section header [section]
+        const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            const sectionName = sectionMatch[1];
+            const parts = sectionName.split(".");
+            let target = result;
+            for (const part of parts) {
+                if (!(part in target)) {
+                    target[part] = {};
+                }
+                target = target[part];
+            }
+            currentSection = target;
+            continue;
+        }
+        // key = value
+        const kvMatch = trimmed.match(/^([^=]+)=\s*(.*)$/);
+        if (kvMatch) {
+            const key = kvMatch[1].trim();
+            const val = kvMatch[2].trim();
+            currentSection[key] = parseTomlValue(val);
+        }
+    }
+    return result;
+}
+function parseTomlValue(val) {
+    if (val === "true")
+        return true;
+    if (val === "false")
+        return false;
+    if (/^-?\d+$/.test(val))
+        return parseInt(val, 10);
+    if (/^-?\d+\.\d+$/.test(val))
+        return parseFloat(val);
+    if ((val.startsWith('"') && val.endsWith('"')) ||
+        (val.startsWith("'") && val.endsWith("'"))) {
+        return val.slice(1, -1);
+    }
+    // Arrays
+    if (val.startsWith("[") && val.endsWith("]")) {
+        const inner = val.slice(1, -1).trim();
+        if (inner === "")
+            return [];
+        return inner.split(",").map((item) => parseTomlValue(item.trim()));
+    }
+    return val;
+}
+// ---------------------------------------------------------------------------
+// Serializers
+// ---------------------------------------------------------------------------
+function toYaml(data, indent = 0) {
+    const prefix = "  ".repeat(indent);
+    if (data === null || data === undefined)
+        return `${prefix}null\n`;
+    if (typeof data === "boolean")
+        return `${prefix}${data}\n`;
+    if (typeof data === "number")
+        return `${prefix}${data}\n`;
+    if (typeof data === "string") {
+        if (data.includes("\n") || data.includes(": ") || data.includes("#")) {
+            return `${prefix}"${data.replace(/"/g, '\\"')}"\n`;
+        }
+        return `${prefix}${data}\n`;
+    }
+    if (Array.isArray(data)) {
+        if (data.length === 0)
+            return `${prefix}[]\n`;
+        let out = "";
+        for (const item of data) {
+            if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+                const entries = Object.entries(item);
+                if (entries.length > 0) {
+                    const [firstKey, firstVal] = entries[0];
+                    out += `${prefix}- ${firstKey}: ${scalarToYaml(firstVal)}\n`;
+                    for (let i = 1; i < entries.length; i++) {
+                        out += `${prefix}  ${entries[i][0]}: ${scalarToYaml(entries[i][1])}\n`;
+                    }
+                    continue;
+                }
+            }
+            out += `${prefix}- ${scalarToYaml(item)}\n`;
+        }
+        return out;
+    }
+    if (typeof data === "object") {
+        const obj = data;
+        const keys = Object.keys(obj);
+        if (keys.length === 0)
+            return `${prefix}{}\n`;
+        let out = "";
+        for (const key of keys) {
+            const val = obj[key];
+            if (typeof val === "object" &&
+                val !== null &&
+                !Array.isArray(val) &&
+                Object.keys(val).length > 0) {
+                out += `${prefix}${key}:\n`;
+                out += toYaml(val, indent + 1);
+            }
+            else if (Array.isArray(val)) {
+                out += `${prefix}${key}:\n`;
+                out += toYaml(val, indent + 1);
+            }
+            else {
+                out += `${prefix}${key}: ${scalarToYaml(val)}\n`;
+            }
+        }
+        return out;
+    }
+    return `${prefix}${String(data)}\n`;
+}
+function scalarToYaml(val) {
+    if (val === null || val === undefined)
+        return "null";
+    if (typeof val === "boolean")
+        return String(val);
+    if (typeof val === "number")
+        return String(val);
+    if (typeof val === "string") {
+        if (val.includes(": ") || val.includes("#") || val.includes("\n")) {
+            return `"${val.replace(/"/g, '\\"')}"`;
+        }
+        return val;
+    }
+    return JSON.stringify(val);
+}
+function toToml(data, sectionPath = "") {
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        return String(data);
+    }
+    const obj = data;
+    let topLevel = "";
+    let sections = "";
+    for (const [key, val] of Object.entries(obj)) {
+        if (typeof val === "object" &&
+            val !== null &&
+            !Array.isArray(val)) {
+            const path = sectionPath ? `${sectionPath}.${key}` : key;
+            sections += `[${path}]\n`;
+            sections += toToml(val, path);
+            sections += "\n";
+        }
+        else {
+            topLevel += `${key} = ${toTomlValue(val)}\n`;
+        }
+    }
+    return topLevel + sections;
+}
+function toTomlValue(val) {
+    if (val === null || val === undefined)
+        return '""';
+    if (typeof val === "boolean")
+        return String(val);
+    if (typeof val === "number")
+        return String(val);
+    if (typeof val === "string")
+        return `"${val.replace(/"/g, '\\"')}"`;
+    if (Array.isArray(val)) {
+        return `[${val.map((v) => toTomlValue(v)).join(", ")}]`;
+    }
+    return JSON.stringify(val);
+}
+function parse(text, format) {
+    switch (format) {
+        case "json":
+            return JSON.parse(text);
+        case "yaml":
+            return parseYaml(text);
+        case "toml":
+            return parseToml(text);
+        default:
+            throw new Error(`Unsupported input format: ${format}`);
+    }
+}
+function serialize(data, format) {
+    switch (format) {
+        case "json":
+            return JSON.stringify(data, null, 2);
+        case "yaml":
+            return toYaml(data).trimEnd();
+        case "toml":
+            return toToml(data).trimEnd();
+        default:
+            throw new Error(`Unsupported output format: ${format}`);
+    }
+}
+registerTool({
+    name: "yaml_convert",
+    description: "Convert between YAML, JSON, and TOML formats",
+    pro: true,
+    inputSchema: {
+        type: "object",
+        properties: {
+            text: { type: "string", description: "Input text to convert" },
+            from: {
+                type: "string",
+                enum: ["yaml", "json", "toml"],
+                description: "Source format",
+            },
+            to: {
+                type: "string",
+                enum: ["yaml", "json", "toml"],
+                description: "Target format",
+            },
+        },
+        required: ["text", "from", "to"],
+    },
+    handler: async (args) => {
+        const text = args.text;
+        const from = args.from;
+        const to = args.to;
+        if (!text.trim())
+            throw new Error("Input text is empty");
+        const data = parse(text, from);
+        const output = serialize(data, to);
+        return [
+            `=== Converted ${from.toUpperCase()} → ${to.toUpperCase()} ===`,
+            "",
+            output,
+        ].join("\n");
+    },
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "revxl-devtools",
+  "version": "1.0.0",
+  "description": "17 developer tools for AI agents. JSON, JWT, regex, cron, secrets scanner. Free core + Pro ($7).",
+  "type": "module",
+  "bin": {
+    "revxl-devtools": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": ["mcp", "developer-tools", "json", "jwt", "regex", "claude", "cursor", "ai-tools", "mcp-server"],
+  "author": "RevXL <john@revxl.net>",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "tsx": "^4.19.0",
+    "@types/node": "^22.10.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/auth.ts

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

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

@@ -0,0 +1,132 @@
+// ---------------------------------------------------------------------------
+// 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");
+}