revxl-devtools 1.0.0

package/dist/tools/secrets-scan.js

@@ -0,0 +1,173 @@
+import { registerTool } from "../registry.js";
+const PATTERNS = [
+    {
+        type: "AWS Access Key",
+        pattern: /AKIA[0-9A-Z]{16}/g,
+        severity: "critical",
+        recommendation: "Rotate this AWS access key immediately in IAM console",
+    },
+    {
+        type: "AWS Secret Key",
+        pattern: /(?:aws_secret_access_key|secret_access_key|aws_secret)\s*[=:]\s*["']?([A-Za-z0-9/+=]{40})["']?/gi,
+        severity: "critical",
+        recommendation: "Rotate AWS credentials and revoke the exposed secret key",
+    },
+    {
+        type: "GitHub Token",
+        pattern: /gh[pors]_[A-Za-z0-9_]{36,255}/g,
+        severity: "critical",
+        recommendation: "Revoke this GitHub token at github.com/settings/tokens",
+    },
+    {
+        type: "Stripe Secret Key",
+        pattern: /sk_live_[A-Za-z0-9]{24,}/g,
+        severity: "critical",
+        recommendation: "Roll this Stripe key in the Dashboard immediately",
+    },
+    {
+        type: "Stripe Publishable Key",
+        pattern: /pk_live_[A-Za-z0-9]{24,}/g,
+        severity: "high",
+        recommendation: "While publishable, review if this key should be public",
+    },
+    {
+        type: "Slack Token",
+        pattern: /xox[bpors]-[A-Za-z0-9-]{10,}/g,
+        severity: "critical",
+        recommendation: "Revoke this Slack token in your workspace admin settings",
+    },
+    {
+        type: "Private Key",
+        pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/g,
+        severity: "critical",
+        recommendation: "Remove this private key and generate a new key pair",
+    },
+    {
+        type: "JWT Token",
+        pattern: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+        severity: "high",
+        recommendation: "Revoke this JWT and rotate the signing secret",
+    },
+    {
+        type: "Anthropic API Key",
+        pattern: /sk-ant-[A-Za-z0-9_-]{20,}/g,
+        severity: "critical",
+        recommendation: "Rotate this Anthropic API key in your account settings",
+    },
+    {
+        type: "OpenAI API Key",
+        pattern: /sk-[A-Za-z0-9]{20,}/g,
+        severity: "critical",
+        recommendation: "Rotate this OpenAI API key at platform.openai.com",
+    },
+    {
+        type: "Generic API Key/Token",
+        pattern: /(?:api[_-]?key|api[_-]?token|access[_-]?token|auth[_-]?token)\s*[=:]\s*["']?([A-Za-z0-9_\-/.+=]{16,})["']?/gi,
+        severity: "medium",
+        recommendation: "Review if this API key/token should be in source code",
+    },
+    {
+        type: "Generic Password",
+        pattern: /(?:password|passwd|pwd)\s*[=:]\s*["']([^"'\s]{8,})["']/gi,
+        severity: "high",
+        recommendation: "Move this password to a secrets manager or environment variable",
+    },
+    {
+        type: "Generic Secret",
+        pattern: /(?:secret|secret_key)\s*[=:]\s*["']([^"'\s]{8,})["']/gi,
+        severity: "high",
+        recommendation: "Move this secret to a secrets manager or environment variable",
+    },
+    {
+        type: "Connection String",
+        pattern: /(?:postgres|postgresql|mysql|mongodb|redis):\/\/[^\s"']{10,}/gi,
+        severity: "critical",
+        recommendation: "Move this connection string to an environment variable. It may contain credentials.",
+    },
+];
+function maskSecret(secret) {
+    if (secret.length <= 12)
+        return secret.slice(0, 4) + "****";
+    return secret.slice(0, 8) + "..." + secret.slice(-4);
+}
+function scanText(text) {
+    const lines = text.split("\n");
+    const findings = [];
+    const seen = new Set();
+    for (const patternDef of PATTERNS) {
+        // Reset regex lastIndex for global patterns
+        patternDef.pattern.lastIndex = 0;
+        let match;
+        while ((match = patternDef.pattern.exec(text)) !== null) {
+            const fullMatch = match[0];
+            const secret = match[1] || fullMatch;
+            // Deduplicate
+            const key = `${patternDef.type}:${fullMatch}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            // Find line number
+            const offset = match.index;
+            let lineNum = 1;
+            for (let i = 0; i < offset && i < text.length; i++) {
+                if (text[i] === "\n")
+                    lineNum++;
+            }
+            findings.push({
+                type: patternDef.type,
+                masked: maskSecret(secret),
+                line: lineNum,
+                severity: patternDef.severity,
+                recommendation: patternDef.recommendation,
+            });
+        }
+    }
+    // Sort by severity then line number
+    const severityOrder = { critical: 0, high: 1, medium: 2 };
+    findings.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity] || a.line - b.line);
+    return findings;
+}
+registerTool({
+    name: "secrets_scan",
+    description: "Scan text for leaked secrets, API keys, tokens, passwords, and connection strings",
+    pro: true,
+    inputSchema: {
+        type: "object",
+        properties: {
+            text: {
+                type: "string",
+                description: "Text content to scan for secrets",
+            },
+        },
+        required: ["text"],
+    },
+    handler: async (args) => {
+        const text = args.text;
+        if (!text.trim())
+            throw new Error("Text is empty");
+        const findings = scanText(text);
+        if (findings.length === 0) {
+            return "No secrets detected. The text appears clean.";
+        }
+        const critical = findings.filter((f) => f.severity === "critical").length;
+        const high = findings.filter((f) => f.severity === "high").length;
+        const medium = findings.filter((f) => f.severity === "medium").length;
+        const lines = [
+            `=== Secrets Scan: Found ${findings.length} secret${findings.length === 1 ? "" : "s"}: ${critical} critical, ${high} high, ${medium} medium ===`,
+            "",
+        ];
+        for (const finding of findings) {
+            const severityLabel = finding.severity === "critical"
+                ? "CRITICAL"
+                : finding.severity === "high"
+                    ? "HIGH"
+                    : "MEDIUM";
+            lines.push(`[${severityLabel}] ${finding.type}`);
+            lines.push(`  Line: ${finding.line}`);
+            lines.push(`  Preview: ${finding.masked}`);
+            lines.push(`  Action: ${finding.recommendation}`);
+            lines.push("");
+        }
+        return lines.join("\n").trimEnd();
+    },
+});

package/dist/tools/sql-format.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/sql-format.js

@@ -0,0 +1,157 @@
+import { registerTool } from "../registry.js";
+// ---------------------------------------------------------------------------
+// SQL Formatter — normalize whitespace, add newlines before major clauses,
+// indent columns and conditions
+// ---------------------------------------------------------------------------
+const MAJOR_CLAUSES = [
+    "SELECT",
+    "FROM",
+    "WHERE",
+    "INNER JOIN",
+    "LEFT JOIN",
+    "RIGHT JOIN",
+    "FULL JOIN",
+    "CROSS JOIN",
+    "JOIN",
+    "ON",
+    "GROUP BY",
+    "ORDER BY",
+    "HAVING",
+    "LIMIT",
+    "OFFSET",
+    "INSERT INTO",
+    "VALUES",
+    "UPDATE",
+    "SET",
+    "DELETE FROM",
+    "WITH",
+    "UNION ALL",
+    "UNION",
+    "EXCEPT",
+    "INTERSECT",
+];
+function formatSQL(sql, _dialect) {
+    // Normalize whitespace: collapse runs of whitespace into single space
+    let normalized = sql.replace(/\s+/g, " ").trim();
+    // Uppercase major clauses and add newlines before them
+    // Sort clauses longest-first so multi-word clauses match before single-word
+    const sortedClauses = [...MAJOR_CLAUSES].sort((a, b) => b.length - a.length);
+    for (const clause of sortedClauses) {
+        const pattern = new RegExp(`\\b${clause}\\b`, "gi");
+        normalized = normalized.replace(pattern, `\n${clause}`);
+    }
+    // Clean up: remove leading newline
+    normalized = normalized.replace(/^\n/, "");
+    // Split into lines for indentation processing
+    const lines = normalized.split("\n").map((l) => l.trim());
+    const result = [];
+    for (const line of lines) {
+        if (!line)
+            continue;
+        // Check if this line starts with a major clause
+        const upperLine = line.toUpperCase();
+        const startsWithClause = sortedClauses.some((c) => upperLine.startsWith(c));
+        if (startsWithClause) {
+            // Find where the clause keyword ends
+            const matchedClause = sortedClauses.find((c) => upperLine.startsWith(c));
+            if (matchedClause) {
+                const rest = line.slice(matchedClause.length).trim();
+                if (matchedClause === "SELECT" ||
+                    matchedClause === "GROUP BY" ||
+                    matchedClause === "ORDER BY") {
+                    // Split comma-separated items onto separate indented lines
+                    if (rest) {
+                        const items = splitTopLevel(rest, ",");
+                        if (items.length > 1) {
+                            result.push(matchedClause);
+                            for (let i = 0; i < items.length; i++) {
+                                const comma = i < items.length - 1 ? "," : "";
+                                result.push(`  ${items[i].trim()}${comma}`);
+                            }
+                            continue;
+                        }
+                    }
+                }
+                if (matchedClause === "WHERE" || matchedClause === "HAVING") {
+                    // Indent AND/OR conditions
+                    if (rest) {
+                        const withConditions = rest
+                            .replace(/\b(AND)\b/gi, "\n  AND")
+                            .replace(/\b(OR)\b/gi, "\n  OR");
+                        const condLines = withConditions
+                            .split("\n")
+                            .map((l) => l.trim())
+                            .filter(Boolean);
+                        result.push(`${matchedClause}`);
+                        for (const cl of condLines) {
+                            result.push(`  ${cl}`);
+                        }
+                        continue;
+                    }
+                }
+                result.push(line);
+            }
+            else {
+                result.push(line);
+            }
+        }
+        else {
+            result.push(`  ${line}`);
+        }
+    }
+    return result.join("\n");
+}
+/**
+ * Split a string by a delimiter, but only at the top level (not inside parens).
+ */
+function splitTopLevel(s, delimiter) {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === "(")
+            depth++;
+        else if (ch === ")")
+            depth--;
+        if (ch === delimiter && depth === 0) {
+            parts.push(current);
+            current = "";
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current.trim())
+        parts.push(current);
+    return parts;
+}
+registerTool({
+    name: "sql_format",
+    description: "Format and prettify SQL queries with proper indentation and clause separation",
+    pro: true,
+    inputSchema: {
+        type: "object",
+        properties: {
+            sql: { type: "string", description: "SQL query to format" },
+            dialect: {
+                type: "string",
+                enum: ["standard", "postgresql", "mysql", "sqlite"],
+                description: "SQL dialect (default: standard)",
+            },
+        },
+        required: ["sql"],
+    },
+    handler: async (args) => {
+        const sql = args.sql;
+        const dialect = args.dialect || "standard";
+        if (!sql.trim())
+            throw new Error("SQL string is empty");
+        const formatted = formatSQL(sql, dialect);
+        return [
+            `=== Formatted SQL (${dialect}) ===`,
+            "",
+            formatted,
+        ].join("\n");
+    },
+});

package/dist/tools/timestamp.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/timestamp.js

@@ -0,0 +1,72 @@
+import { registerTool } from "../registry.js";
+function relativeTime(date) {
+    const now = Date.now();
+    const diffMs = now - date.getTime();
+    const absDiff = Math.abs(diffMs);
+    const suffix = diffMs >= 0 ? "ago" : "from now";
+    const seconds = Math.floor(absDiff / 1000);
+    if (seconds < 60)
+        return `${seconds} seconds ${suffix}`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes} minutes ${suffix}`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours} hours ${suffix}`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `${days} days ${suffix}`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `${months} months ${suffix}`;
+    const years = Math.floor(days / 365);
+    return `${years} years ${suffix}`;
+}
+registerTool({
+    name: "timestamp",
+    description: "Convert between timestamp formats: epoch seconds, epoch ms, ISO 8601, human-readable",
+    pro: false,
+    inputSchema: {
+        type: "object",
+        properties: {
+            value: {
+                type: "string",
+                description: 'Timestamp value: "now", epoch seconds, epoch milliseconds, or ISO 8601 string',
+            },
+        },
+        required: ["value"],
+    },
+    handler: async (args) => {
+        const value = args.value.trim();
+        let date;
+        if (value.toLowerCase() === "now") {
+            date = new Date();
+        }
+        else if (/^\d{10}$/.test(value)) {
+            // Epoch seconds
+            date = new Date(parseInt(value, 10) * 1000);
+        }
+        else if (/^\d{13}$/.test(value)) {
+            // Epoch milliseconds
+            date = new Date(parseInt(value, 10));
+        }
+        else if (value.includes("T") || value.includes("-")) {
+            date = new Date(value);
+        }
+        else {
+            throw new Error(`Cannot parse timestamp: "${value}". Use "now", epoch seconds (10 digits), epoch ms (13 digits), or ISO 8601.`);
+        }
+        if (isNaN(date.getTime())) {
+            throw new Error(`Invalid date: "${value}"`);
+        }
+        const epochS = Math.floor(date.getTime() / 1000);
+        const epochMs = date.getTime();
+        return [
+            `epoch_seconds: ${epochS}`,
+            `epoch_ms:      ${epochMs}`,
+            `iso8601:       ${date.toISOString()}`,
+            `human:         ${date.toUTCString()}`,
+            `relative:      ${relativeTime(date)}`,
+        ].join("\n");
+    },
+});

package/dist/tools/url-encode.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/url-encode.js

@@ -0,0 +1,26 @@
+import { registerTool } from "../registry.js";
+registerTool({
+    name: "url_encode",
+    description: "URL encode or decode strings",
+    pro: false,
+    inputSchema: {
+        type: "object",
+        properties: {
+            text: { type: "string", description: "Text to encode or encoded string to decode" },
+            action: {
+                type: "string",
+                enum: ["encode", "decode"],
+                description: "encode or decode",
+            },
+        },
+        required: ["text", "action"],
+    },
+    handler: async (args) => {
+        const text = args.text;
+        const action = args.action;
+        if (action === "encode") {
+            return encodeURIComponent(text);
+        }
+        return decodeURIComponent(text);
+    },
+});

package/dist/tools/uuid.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/uuid.js

@@ -0,0 +1,24 @@
+import { randomUUID } from "node:crypto";
+import { registerTool } from "../registry.js";
+registerTool({
+    name: "uuid_generate",
+    description: "Generate one or more v4 UUIDs",
+    pro: false,
+    inputSchema: {
+        type: "object",
+        properties: {
+            count: {
+                type: "number",
+                description: "Number of UUIDs to generate (default: 1, max: 10)",
+            },
+        },
+    },
+    handler: async (args) => {
+        let count = Math.min(Math.max(args.count || 1, 1), 10);
+        const uuids = [];
+        for (let i = 0; i < count; i++) {
+            uuids.push(randomUUID());
+        }
+        return uuids.join("\n");
+    },
+});

package/dist/tools/yaml-convert.d.ts

@@ -0,0 +1 @@
+export {};