simplyutils-mcp 0.0.0-stage → 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Memegician LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,84 @@
-# Temporary Holding Version
+# SimplyUtils MCP server
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Everyday developer and text tools from [SimplyUtils](https://simplyutils.com) for Claude, ChatGPT, Cursor and any other [Model Context Protocol](https://modelcontextprotocol.io) client.
+
+Ask things like *"format this JSON"*, *"make a QR code for https://example.com"*, *"convert 5 miles to km"* or *"test this regex against my log line"*. The answers are computed directly: no AI calls, no external lookups, and nothing is stored. Each answer links to the matching free tool on simplyutils.com, where you can do more with it.
+
+## Tools
+
+| Tool | What it does | On the web |
+|---|---|---|
+| `format_json` | Validate, pretty-print or minify JSON, optionally sorting keys | [JSON Formatter](https://simplyutils.com/tool/json-formatter) |
+| `generate_qr_code` | Static QR code for a link or text, as PNG and SVG | [QR Code Generator](https://simplyutils.com/tool/qr-code-generator) |
+| `convert_units` | Length, weight, temperature, volume, speed, area, data and time | [Unit Converter](https://simplyutils.com/tool/unit-converter) |
+| `generate_password` | Cryptographically random passwords (8–128 characters) | [Password Generator](https://simplyutils.com/tool/password-generator) |
+| `generate_uuid` | Random version 4 UUIDs | [UUID Generator](https://simplyutils.com/tool/uuid-generator) |
+| `hash_text` | MD5, SHA-1, SHA-256, SHA-384, SHA-512 hex digests | [Hash Generator](https://simplyutils.com/tool/hash-generator) |
+| `base64` | Encode or decode UTF-8 text (standard or URL-safe) | [Base64 Encoder](https://simplyutils.com/tool/base64) |
+| `test_regex` | Run a JavaScript regex and list matches and capture groups | [Regex Tester](https://simplyutils.com/tool/regex-tester) |
+| `convert_timestamp` | Unix seconds or milliseconds ↔ ISO 8601, UTC and any time zone | [Timestamp Converter](https://simplyutils.com/tool/timestamp-converter) |
+| `count_words` | Words, characters, sentences, paragraphs and reading time | [Word Counter](https://simplyutils.com/tool/word-counter) |
+
+All tools are read-only.
+
+## Connect
+
+The hosted server is free to use at:
+
+```
+https://api.simplyutils.com/mcp
+```
+
+**Claude (claude.ai and desktop):** Settings → Connectors → *Add custom connector*, then paste the URL above.
+
+**Claude Code:**
+
+```bash
+claude mcp add --transport http simplyutils https://api.simplyutils.com/mcp
+```
+
+**ChatGPT:** Settings → Apps & Connectors → enable developer mode → *Create*, then paste the URL above.
+
+**Cursor, VS Code and other clients** (`mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "simplyutils": { "url": "https://api.simplyutils.com/mcp" }
+  }
+}
+```
+
+**Run it locally instead** (no network needed after install):
+
+```json
+{
+  "mcpServers": {
+    "simplyutils": { "command": "npx", "args": ["-y", "simplyutils-mcp"] }
+  }
+}
+```
+
+## Limits
+
+- Text inputs up to 100 KB; QR content up to 800 bytes.
+- Regex patterns stop after 0.5 seconds and return at most 200 matches.
+- The hosted endpoint allows 60 requests per minute per IP address.
+
+## Privacy
+
+Tool inputs are processed in memory to produce the answer and are not stored or logged by this server. The hosted endpoint runs on SimplyUtils infrastructure; see the [SimplyUtils privacy policy](https://simplyutils.com/privacy).
+
+## Develop
+
+```bash
+npm install
+npm test          # unit and end-to-end MCP tests
+npm run build
+npm start         # HTTP server on http://127.0.0.1:5016/mcp
+npm run start:stdio
+```
+
+## License
+
+MIT © Memegician LLC. SimplyUtils is a product of Memegician LLC.

package/dist/http.js

@@ -0,0 +1,31 @@
+// Remote MCP endpoint (Streamable HTTP, stateless). Runs behind Nginx at https://api.simplyutils.com/mcp.
+import express from "express";
+import { rateLimit } from "express-rate-limit";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "./server.js";
+const port = Number(process.env.PORT ?? 5016);
+const host = process.env.HOST ?? "127.0.0.1";
+const allowedHosts = (process.env.ALLOWED_HOSTS ?? "api.simplyutils.com,localhost,127.0.0.1").split(",").map(h => h.trim()).filter(Boolean);
+const app = createMcpExpressApp({ host, allowedHosts: allowedHosts.flatMap(h => [h, `${h}:${port}`]) });
+app.set("trust proxy", 1); // Nginx in front: rate-limit by the real client IP.
+app.use(express.json({ limit: "200kb" }));
+app.use("/mcp", rateLimit({ windowMs: 60_000, limit: 60, standardHeaders: "draft-7", legacyHeaders: false }));
+app.post("/mcp", async (req, res) => {
+    // Stateless: a fresh server and transport per request, closed when the response ends.
+    const server = createServer();
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+    res.on("close", () => { void transport.close(); void server.close(); });
+    try {
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    }
+    catch {
+        if (!res.headersSent)
+            res.status(500).json({ jsonrpc: "2.0", error: { code: -32603, message: "Internal server error" }, id: null });
+    }
+});
+// No sessions or server-sent streams in stateless mode.
+app.all("/mcp", (_req, res) => res.status(405).set("Allow", "POST").json({ jsonrpc: "2.0", error: { code: -32000, message: "Method not allowed." }, id: null }));
+app.get("/health", (_req, res) => res.json({ ok: true }));
+app.listen(port, host, () => console.log(`SimplyUtils MCP listening on http://${host}:${port}/mcp`));

package/dist/server.js

@@ -0,0 +1,134 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import * as tools from "./tools.js";
+const readOnly = { readOnlyHint: true, destructiveHint: false, openWorldHint: false };
+const text = (body, slug) => ({
+    content: [{ type: "text", text: `${body}\n\nOpen in SimplyUtils: ${tools.toolUrl(slug)}` }],
+});
+/** Tool errors go back to the model as readable text instead of failing the call. */
+async function run(slug, work) {
+    try {
+        return text(await work(), slug);
+    }
+    catch (error) {
+        return { ...text(`Error: ${error.message}`, slug), isError: true };
+    }
+}
+export function createServer() {
+    const server = new McpServer({ name: "simplyutils", title: "SimplyUtils", version: "1.0.2", websiteUrl: tools.SITE }, { instructions: "Everyday developer and text utilities from SimplyUtils (simplyutils.com). Results are computed directly, with no AI and no external lookups. Each answer links to the matching free tool on simplyutils.com." });
+    server.registerTool("format_json", {
+        title: "Format or minify JSON",
+        description: "Validate JSON and return it pretty-printed or minified, optionally with object keys sorted A-Z (recursively; array order is kept). Returns the formatted JSON as text. Invalid JSON returns an error naming the problem and its position. Input up to 100 KB.",
+        inputSchema: {
+            json: z.string().describe("The JSON text to validate and format"),
+            indent: z.enum(["2", "4", "tab", "minify"]).default("2").describe("2 or 4 spaces, a tab, or minify to remove all whitespace"),
+            sortKeys: z.boolean().default(false).describe("Sort object keys alphabetically at every level"),
+        },
+        annotations: readOnly,
+    }, ({ json, indent, sortKeys }) => run("json-formatter", () => tools.formatJson(json, indent, sortKeys)));
+    server.registerTool("generate_qr_code", {
+        title: "Generate a QR code",
+        description: "Make a static QR code for a link or any text, up to 800 UTF-8 bytes. Returns a 512 px PNG image plus the SVG markup. The data is stored in the code itself, so it never expires and needs no account. Light-on-dark colors are allowed, but some older scanners need dark on light. Errors are returned for empty text, content over 800 bytes, or colors that are not six-digit hex.",
+        inputSchema: {
+            text: z.string().describe("Link or text to encode"),
+            errorCorrection: z.enum(["L", "M", "Q", "H"]).default("M").describe("Error correction: L 7%, M 15%, Q 25%, H 30% of the code can be damaged and still scan; higher is denser"),
+            foreground: z.string().default("#000000").describe("Six-digit hex color for the modules"),
+            background: z.string().default("#ffffff").describe("Six-digit hex color for the background"),
+        },
+        annotations: readOnly,
+    }, async ({ text: value, errorCorrection, foreground, background }) => {
+        try {
+            const { svg, pngBase64 } = await tools.qrCode(value, errorCorrection, foreground, background);
+            return { content: [
+                    { type: "image", data: pngBase64, mimeType: "image/png" },
+                    { type: "text", text: `SVG:\n${svg}\n\nTest the code with your phone before printing. Customize colors and add a logo: ${tools.toolUrl("qr-code-generator")}` },
+                ] };
+        }
+        catch (error) {
+            return { ...text(`Error: ${error.message}`, "qr-code-generator"), isError: true };
+        }
+    });
+    server.registerTool("convert_units", {
+        title: "Convert units",
+        description: `Convert a number between two units of the same category and return a line such as "5 mi = 8.04672 km" (up to 10 significant digits). Units are matched by symbol or name, case-insensitive. Errors are returned for unknown units, units from another category, non-numeric values and temperatures below absolute zero. Months are 1/12 of a 365-day year. Units by category (symbols): ${tools.unitList()}.`,
+        inputSchema: {
+            value: z.string().describe("A plain number such as 12.5, -40 or 1e6 (no commas or unit text)"),
+            category: z.enum(tools.unitCategories).describe("The kind of quantity; both units must belong to it"),
+            from: z.string().describe("Unit symbol or name, e.g. km or kilometer"),
+            to: z.string().describe("Unit symbol or name, e.g. mi or mile"),
+        },
+        annotations: readOnly,
+    }, ({ value, category, from, to }) => run("unit-converter", () => tools.convertUnits(value, category, from, to).text));
+    server.registerTool("generate_password", {
+        title: "Generate strong passwords",
+        description: "Generate random passwords with Node's cryptographically secure generator. Each enabled character set appears at least once and the result is shuffled. Returns one password per line; every call gives new results. An error is returned if all character sets are turned off. Passwords are not stored or logged.",
+        inputSchema: {
+            length: z.number().int().min(8).max(128).default(16).describe("Characters per password, 8-128"),
+            count: z.number().int().min(1).max(20).default(1).describe("How many passwords to generate, 1-20"),
+            uppercase: z.boolean().default(true).describe("Include A-Z"),
+            lowercase: z.boolean().default(true).describe("Include a-z"),
+            numbers: z.boolean().default(true).describe("Include 0-9"),
+            symbols: z.boolean().default(true).describe("Include symbols such as !@#$%^&*"),
+        },
+        annotations: { ...readOnly, idempotentHint: false },
+    }, ({ length, count, ...sets }) => run("password-generator", () => tools.generatePasswords(length, count, sets).join("\n")));
+    server.registerTool("generate_uuid", {
+        title: "Generate UUIDs",
+        description: "Generate random version 4 UUIDs (RFC 9562) in lowercase 8-4-4-4-12 form, one per line. Every call gives new values.",
+        inputSchema: { count: z.number().int().min(1).max(50).default(1).describe("How many UUIDs to generate, 1-50") },
+        annotations: { ...readOnly, idempotentHint: false },
+    }, ({ count }) => run("uuid-generator", () => tools.generateUuids(count).join("\n")));
+    server.registerTool("hash_text", {
+        title: "Hash text",
+        description: "Hash text (encoded as UTF-8) and return a line such as 'sha256: ba78...' with the lowercase hex digest. The same input always gives the same hash. MD5 and SHA-1 are only for checksums, not security; do not use plain hashes to store passwords. Input up to 100 KB.",
+        inputSchema: {
+            text: z.string().describe("The exact text to hash; spaces and line breaks change the result"),
+            algorithm: z.enum(["md5", "sha1", "sha256", "sha384", "sha512"]).default("sha256").describe("Hash algorithm; sha256 is the usual choice"),
+        },
+        annotations: readOnly,
+    }, ({ text: value, algorithm }) => run("hash-generator", () => `${algorithm}: ${tools.hashText(value, algorithm)}`));
+    server.registerTool("base64", {
+        title: "Base64 encode or decode",
+        description: "Encode text (as UTF-8) to Base64, or decode Base64 back to text, and return the result. Decoding accepts standard and URL-safe alphabets and ignores whitespace; invalid Base64 returns an error. Bytes that are not valid UTF-8 are shown as replacement characters. Input up to 100 KB.",
+        inputSchema: {
+            text: z.string().describe("Text to encode, or Base64 to decode"),
+            mode: z.enum(["encode", "decode"]).describe("encode: text to Base64; decode: Base64 to text"),
+            urlSafe: z.boolean().default(false).describe("When encoding, use - and _ and drop = padding (for URLs and JWTs)"),
+        },
+        annotations: readOnly,
+    }, ({ text: value, mode, urlSafe }) => run("base64", () => tools.base64(value, mode, urlSafe)));
+    server.registerTool("test_regex", {
+        title: "Test a regular expression",
+        description: "Run a JavaScript (ECMAScript) regular expression against text. Returns the match count and, for each match, the matched text, its 0-based index, numbered capture groups and named groups. Returns 'No matches.' when nothing matches. All matches are listed (the g flag is added automatically), up to 200. Invalid patterns or flags return an error explaining why; patterns that run longer than 0.5 seconds are stopped with an error. Text up to 100 KB.",
+        inputSchema: {
+            pattern: z.string().describe("The pattern without surrounding slashes, for example (\\d+)-(?<unit>[a-z]+)"),
+            flags: z.string().default("g").describe("Any of d, g, i, m, s, u, v, y; for example gi for case-insensitive"),
+            text: z.string().describe("The text to search"),
+        },
+        annotations: readOnly,
+    }, ({ pattern, flags, text: value }) => run("regex-tester", () => {
+        const matches = tools.testRegex(pattern, flags, value);
+        if (!matches.length)
+            return "No matches.";
+        return `${matches.length} match${matches.length === 1 ? "" : "es"}:\n` + matches.map((m, i) => `${i + 1}. "${m.match}" at ${m.index}` + (m.groups.length ? ` groups: ${JSON.stringify(m.groups)}` : "") + (m.named ? ` named: ${JSON.stringify(m.named)}` : "")).join("\n");
+    }));
+    server.registerTool("convert_timestamp", {
+        title: "Convert a Unix timestamp or date",
+        description: "Convert a Unix timestamp or a date to Unix seconds, Unix milliseconds, ISO 8601 (UTC), an HTTP-style UTC string and a readable date in the chosen time zone. Numbers with 13 or more digits are read as milliseconds, shorter ones as seconds. Dates without a time zone are read as UTC. Errors are returned for unreadable dates and unknown time zones.",
+        inputSchema: { value: z.string().describe("e.g. 1767225600 or 2026-10-27T09:30:00Z"), timeZone: z.string().default("UTC").describe("IANA time zone, e.g. Asia/Kolkata") },
+        annotations: readOnly,
+    }, ({ value, timeZone }) => run("timestamp-converter", () => {
+        const r = tools.convertTimestamp(value, timeZone);
+        return `Unix seconds: ${r.unixSeconds}\nUnix milliseconds: ${r.unixMilliseconds}\nISO 8601: ${r.iso}\nUTC: ${r.utc}\n${r.timeZone}: ${r.local}`;
+    }));
+    server.registerTool("count_words", {
+        title: "Count words and characters",
+        description: "Count words, characters (with and without spaces), sentences and paragraphs, and estimate reading time at 238 words per minute. Words are runs of letters or digits in any language; hyphenated words and contractions count once. Paragraphs are separated by blank lines. Input up to 100 KB.",
+        inputSchema: { text: z.string().describe("The text to analyze") },
+        annotations: readOnly,
+    }, ({ text: value }) => run("word-counter", () => {
+        const r = tools.countWords(value);
+        return `Words: ${r.words}\nCharacters: ${r.characters}\nCharacters (no spaces): ${r.charactersWithoutSpaces}\nSentences: ${r.sentences}\nParagraphs: ${r.paragraphs}\nReading time: about ${r.readingTimeMinutes} min`;
+    }));
+    return server;
+}

package/dist/stdio.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// Local MCP server over stdio, for `npx simplyutils-mcp` in Claude Desktop, Claude Code, Cursor and others.
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+await createServer().connect(new StdioServerTransport());

package/dist/tools.js

@@ -0,0 +1,179 @@
+// Pure tool logic. No network calls and no AI: every result is computed locally.
+import { createHash, randomInt, randomUUID } from "node:crypto";
+import vm from "node:vm";
+import QRCode from "qrcode";
+import { UNITS, convertUnit } from "./units.js";
+export const SITE = "https://simplyutils.com";
+export const toolUrl = (slug) => `${SITE}/tool/${slug}`;
+const MAX_TEXT_BYTES = 100_000;
+function limitText(text, label = "text") {
+    if (Buffer.byteLength(text, "utf8") > MAX_TEXT_BYTES)
+        throw new Error(`The ${label} is larger than 100 KB. Use a smaller input.`);
+}
+// 1. JSON
+export function formatJson(json, indent = "2", sortKeys = false) {
+    limitText(json, "JSON");
+    let value;
+    try {
+        value = JSON.parse(json);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON: ${error.message}`);
+    }
+    if (sortKeys)
+        value = sortDeep(value);
+    const space = indent === "minify" ? undefined : indent === "tab" ? "\t" : Number(indent);
+    return JSON.stringify(value, null, space);
+}
+function sortDeep(value) {
+    if (Array.isArray(value))
+        return value.map(sortDeep);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.keys(value).sort().map(key => [key, sortDeep(value[key])]));
+    }
+    return value;
+}
+// 2. QR code
+export async function qrCode(text, errorCorrection = "M", foreground = "#000000", background = "#ffffff") {
+    if (!text)
+        throw new Error("Enter the text or link to encode.");
+    if (Buffer.byteLength(text, "utf8") > 800)
+        throw new Error("QR content is limited to 800 UTF-8 bytes so the code stays easy to scan.");
+    for (const color of [foreground, background])
+        if (!/^#[\da-f]{6}$/i.test(color))
+            throw new Error("Use six-digit hex colors such as #000000.");
+    const options = { errorCorrectionLevel: errorCorrection, margin: 4, color: { dark: foreground, light: background } };
+    const [svg, png] = await Promise.all([
+        QRCode.toString(text, { ...options, type: "svg" }),
+        QRCode.toBuffer(text, { ...options, type: "png", width: 512 }),
+    ]);
+    return { svg, pngBase64: png.toString("base64") };
+}
+// 3. Units
+export const unitCategories = Object.keys(UNITS);
+export function unitList() {
+    return unitCategories.map(category => `${category}: ${UNITS[category].units.map(unit => unit.symbol).join(", ")}`).join("; ");
+}
+function unitSymbol(category, unit) {
+    const wanted = unit.trim().toLowerCase();
+    const match = UNITS[category].units.find(candidate => candidate.symbol.toLowerCase() === wanted || candidate.label.toLowerCase() === wanted || candidate.label.toLowerCase() + "s" === wanted);
+    if (!match)
+        throw new Error(`Unknown ${category} unit "${unit}". Use one of: ${UNITS[category].units.map(u => u.symbol).join(", ")}.`);
+    return match;
+}
+export function convertUnits(value, category, from, to) {
+    const source = unitSymbol(category, from), target = unitSymbol(category, to);
+    const result = convertUnit(value, category, source.symbol, target.symbol);
+    return { result, text: `${value} ${source.symbol} = ${result} ${target.symbol}` };
+}
+// 4. Passwords
+const SETS = { uppercase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ", lowercase: "abcdefghijklmnopqrstuvwxyz", numbers: "0123456789", symbols: "!@#$%^&*()-_=+[]{};:,.?/" };
+export function generatePasswords(length = 16, count = 1, sets = {}) {
+    const chosen = Object.keys(SETS).filter(key => sets[key] ?? true);
+    if (!chosen.length)
+        throw new Error("Choose at least one character set.");
+    if (length < chosen.length)
+        throw new Error("The length must allow one character from each chosen set.");
+    const pool = chosen.map(key => SETS[key]).join("");
+    return Array.from({ length: count }, () => {
+        // One character from each chosen set, the rest from the whole pool, then shuffle.
+        const chars = chosen.map(key => SETS[key][randomInt(SETS[key].length)]);
+        while (chars.length < length)
+            chars.push(pool[randomInt(pool.length)]);
+        for (let i = chars.length - 1; i > 0; i--) {
+            const j = randomInt(i + 1);
+            [chars[i], chars[j]] = [chars[j], chars[i]];
+        }
+        return chars.join("");
+    });
+}
+// 5. UUIDs
+export const generateUuids = (count = 1) => Array.from({ length: count }, () => randomUUID());
+// 6. Hashes
+export function hashText(text, algorithm = "sha256") {
+    limitText(text);
+    return createHash(algorithm).update(text, "utf8").digest("hex");
+}
+// 7. Base64
+export function base64(text, mode, urlSafe = false) {
+    limitText(text);
+    if (mode === "encode") {
+        const encoded = Buffer.from(text, "utf8").toString("base64");
+        return urlSafe ? encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "") : encoded;
+    }
+    const clean = text.replace(/\s+/g, "").replace(/-/g, "+").replace(/_/g, "/");
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(clean) || clean.replace(/=+$/, "").length % 4 === 1)
+        throw new Error("This is not valid Base64.");
+    const bytes = Buffer.from(clean, "base64");
+    const decoded = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+    return decoded;
+}
+// 8. Regex, run with a time limit so a slow pattern cannot block the server.
+export function testRegex(pattern, flags, text) {
+    limitText(text);
+    if (pattern.length > 2000)
+        throw new Error("The pattern is longer than 2,000 characters.");
+    if (!/^[dgimsuyv]*$/.test(flags) || new Set(flags).size !== flags.length)
+        throw new Error("Use JavaScript regex flags: d, g, i, m, s, u, v, y.");
+    let regex;
+    try {
+        regex = new RegExp(pattern, flags.includes("g") ? flags : flags + "g");
+    }
+    catch (error) {
+        throw new Error(`Invalid pattern: ${error.message}`);
+    }
+    const context = { regex, text, out: [] };
+    try {
+        vm.runInNewContext(`
+      for (const m of text.matchAll(regex)) {
+        out.push({ match: m[0], index: m.index, groups: m.slice(1).map(g => g === undefined ? null : g), named: m.groups ? { ...m.groups } : undefined });
+        if (out.length >= 200) break;
+      }`, context, { timeout: 500 });
+    }
+    catch (error) {
+        if (/timed out/i.test(String(error)))
+            throw new Error("The pattern took longer than 0.5 seconds (likely catastrophic backtracking). Simplify it.");
+        throw error;
+    }
+    return context.out;
+}
+// 9. Timestamps
+export function convertTimestamp(value, timeZone = "UTC") {
+    const text = value.trim();
+    let date;
+    if (/^-?\d+(\.\d+)?$/.test(text)) {
+        const number = Number(text);
+        // 13+ digits are milliseconds; shorter values are seconds.
+        date = new Date(Math.abs(number) >= 1e12 ? number : number * 1000);
+    }
+    else {
+        // An ISO date-time without a zone would otherwise use the server's local zone; read it as UTC.
+        const isoWithoutZone = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?$/.test(text);
+        date = new Date(isoWithoutZone ? text.replace(" ", "T") + "Z" : text);
+    }
+    if (Number.isNaN(date.getTime()))
+        throw new Error("Enter a Unix timestamp (seconds or milliseconds) or a date such as 2026-10-27T09:30:00Z.");
+    let local;
+    try {
+        local = new Intl.DateTimeFormat("en-US", { timeZone, dateStyle: "full", timeStyle: "long" }).format(date);
+    }
+    catch {
+        throw new Error(`Unknown time zone "${timeZone}". Use an IANA name such as America/New_York.`);
+    }
+    return { unixSeconds: Math.floor(date.getTime() / 1000), unixMilliseconds: date.getTime(), iso: date.toISOString(), utc: date.toUTCString(), local, timeZone };
+}
+// 10. Word count
+export function countWords(text) {
+    limitText(text);
+    const words = text.match(/[\p{L}\p{N}]+(?:['’-][\p{L}\p{N}]+)*/gu) ?? [];
+    const sentences = text.split(/[.!?]+(?=\s|$)/).filter(part => /[\p{L}\p{N}]/u.test(part)).length;
+    const paragraphs = text.split(/\n\s*\n/).filter(part => part.trim()).length;
+    return {
+        words: words.length,
+        characters: [...text].length,
+        charactersWithoutSpaces: [...text.replace(/\s/g, "")].length,
+        sentences,
+        paragraphs,
+        readingTimeMinutes: Math.max(words.length ? 1 : 0, Math.round(words.length / 238)),
+    };
+}

package/dist/units.js

@@ -0,0 +1,130 @@
+// Same tables and rules as the converter at https://simplyutils.com/tool/unit-converter
+function finiteDecimal(input, label) {
+    const text = input.trim();
+    if (!text || !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(text)) {
+        throw new Error(`Enter a valid number for ${label}.`);
+    }
+    const value = Number(text);
+    if (!Number.isFinite(value))
+        throw new Error(`${label} must be a finite number.`);
+    return value;
+}
+/** Up to 10 significant digits, like the website. */
+function formatCalculatorNumber(value) {
+    return Number(value.toPrecision(10)).toString();
+}
+export const UNITS = {
+    length: {
+        label: "Length",
+        units: [
+            { label: "Meter", symbol: "m", toBase: v => v, fromBase: v => v },
+            { label: "Kilometer", symbol: "km", toBase: v => v * 1000, fromBase: v => v / 1000 },
+            { label: "Mile", symbol: "mi", toBase: v => v * 1609.344, fromBase: v => v / 1609.344 },
+            { label: "Foot", symbol: "ft", toBase: v => v * 0.3048, fromBase: v => v / 0.3048 },
+            { label: "Inch", symbol: "in", toBase: v => v * 0.0254, fromBase: v => v / 0.0254 },
+            { label: "Centimeter", symbol: "cm", toBase: v => v / 100, fromBase: v => v * 100 },
+            { label: "Millimeter", symbol: "mm", toBase: v => v / 1000, fromBase: v => v * 1000 },
+            { label: "Yard", symbol: "yd", toBase: v => v * 0.9144, fromBase: v => v / 0.9144 },
+            { label: "Nautical Mile", symbol: "nmi", toBase: v => v * 1852, fromBase: v => v / 1852 },
+        ],
+    },
+    weight: {
+        label: "Weight",
+        units: [
+            { label: "Kilogram", symbol: "kg", toBase: v => v, fromBase: v => v },
+            { label: "Gram", symbol: "g", toBase: v => v / 1000, fromBase: v => v * 1000 },
+            { label: "Pound", symbol: "lb", toBase: v => v * 0.45359237, fromBase: v => v / 0.45359237 },
+            { label: "Ounce", symbol: "oz", toBase: v => v * 0.028349523125, fromBase: v => v / 0.028349523125 },
+            { label: "Metric Ton", symbol: "t", toBase: v => v * 1000, fromBase: v => v / 1000 },
+            { label: "Milligram", symbol: "mg", toBase: v => v / 1e6, fromBase: v => v * 1e6 },
+            { label: "Stone", symbol: "st", toBase: v => v * 6.35029318, fromBase: v => v / 6.35029318 },
+        ],
+    },
+    temperature: {
+        label: "Temperature",
+        units: [
+            { label: "Celsius", symbol: "°C", toBase: v => v, fromBase: v => v },
+            { label: "Fahrenheit", symbol: "°F", toBase: v => (v - 32) * 5 / 9, fromBase: v => v * 9 / 5 + 32 },
+            { label: "Kelvin", symbol: "K", toBase: v => v - 273.15, fromBase: v => v + 273.15 },
+        ],
+    },
+    volume: {
+        label: "Volume",
+        units: [
+            { label: "Liter", symbol: "L", toBase: v => v, fromBase: v => v },
+            { label: "Milliliter", symbol: "mL", toBase: v => v / 1000, fromBase: v => v * 1000 },
+            { label: "Gallon (US)", symbol: "gal", toBase: v => v * 3.785411784, fromBase: v => v / 3.785411784 },
+            { label: "Fluid Ounce (US)", symbol: "fl oz", toBase: v => v * 0.0295735295625, fromBase: v => v / 0.0295735295625 },
+            { label: "Cup (US customary)", symbol: "cup", toBase: v => v * 0.2365882365, fromBase: v => v / 0.2365882365 },
+            { label: "Tablespoon (US)", symbol: "tbsp", toBase: v => v * 0.01478676478125, fromBase: v => v / 0.01478676478125 },
+            { label: "Cubic Meter", symbol: "m³", toBase: v => v * 1000, fromBase: v => v / 1000 },
+        ],
+    },
+    speed: {
+        label: "Speed",
+        units: [
+            { label: "km/h", symbol: "km/h", toBase: v => v, fromBase: v => v },
+            { label: "mph", symbol: "mph", toBase: v => v * 1.609344, fromBase: v => v / 1.609344 },
+            { label: "m/s", symbol: "m/s", toBase: v => v * 3.6, fromBase: v => v / 3.6 },
+            { label: "Knot", symbol: "kn", toBase: v => v * 1.852, fromBase: v => v / 1.852 },
+            { label: "ft/s", symbol: "ft/s", toBase: v => v * 1.09728, fromBase: v => v / 1.09728 },
+        ],
+    },
+    area: {
+        label: "Area",
+        units: [
+            { label: "Square Meter", symbol: "m²", toBase: v => v, fromBase: v => v },
+            { label: "Square Kilometer", symbol: "km²", toBase: v => v * 1e6, fromBase: v => v / 1e6 },
+            { label: "Square Mile", symbol: "mi²", toBase: v => v * 2589988.110336, fromBase: v => v / 2589988.110336 },
+            { label: "Square Foot", symbol: "ft²", toBase: v => v * 0.09290304, fromBase: v => v / 0.09290304 },
+            { label: "Acre", symbol: "ac", toBase: v => v * 4046.8564224, fromBase: v => v / 4046.8564224 },
+            { label: "Hectare", symbol: "ha", toBase: v => v * 10000, fromBase: v => v / 10000 },
+        ],
+    },
+    data: {
+        label: "Data",
+        units: [
+            { label: "Byte", symbol: "B", toBase: v => v, fromBase: v => v },
+            { label: "Kilobyte", symbol: "KB", toBase: v => v * 1000, fromBase: v => v / 1000 },
+            { label: "Megabyte", symbol: "MB", toBase: v => v * 1e6, fromBase: v => v / 1e6 },
+            { label: "Gigabyte", symbol: "GB", toBase: v => v * 1e9, fromBase: v => v / 1e9 },
+            { label: "Terabyte", symbol: "TB", toBase: v => v * 1e12, fromBase: v => v / 1e12 },
+            { label: "Bit", symbol: "bit", toBase: v => v / 8, fromBase: v => v * 8 },
+            { label: "Kibibyte", symbol: "KiB", toBase: v => v * 1024, fromBase: v => v / 1024 },
+            { label: "Mebibyte", symbol: "MiB", toBase: v => v * 2 ** 20, fromBase: v => v / 2 ** 20 },
+            { label: "Gibibyte", symbol: "GiB", toBase: v => v * 2 ** 30, fromBase: v => v / 2 ** 30 },
+            { label: "Tebibyte", symbol: "TiB", toBase: v => v * 2 ** 40, fromBase: v => v / 2 ** 40 },
+        ],
+    },
+    time: {
+        label: "Time",
+        units: [
+            { label: "Second", symbol: "s", toBase: v => v, fromBase: v => v },
+            { label: "Minute", symbol: "min", toBase: v => v * 60, fromBase: v => v / 60 },
+            { label: "Hour", symbol: "h", toBase: v => v * 3600, fromBase: v => v / 3600 },
+            { label: "Day", symbol: "d", toBase: v => v * 86400, fromBase: v => v / 86400 },
+            { label: "Week", symbol: "wk", toBase: v => v * 604800, fromBase: v => v / 604800 },
+            { label: "Month (1/12 of 365 days)", symbol: "mo", toBase: v => v * 2628000, fromBase: v => v / 2628000 },
+            { label: "Year (365 days)", symbol: "yr", toBase: v => v * 31536000, fromBase: v => v / 31536000 },
+            { label: "Millisecond", symbol: "ms", toBase: v => v / 1000, fromBase: v => v * 1000 },
+        ],
+    },
+};
+export function convertUnit(input, category, from, to) {
+    const value = finiteDecimal(input, "the value");
+    const units = UNITS[category]?.units;
+    const source = units?.find(unit => unit.symbol === from), target = units?.find(unit => unit.symbol === to);
+    if (!source || !target)
+        throw new Error("Choose valid units from the same category.");
+    let base = source.toBase(value);
+    if (category === "temperature") {
+        const minimum = from === "K" ? 0 : from === "\u00b0F" ? -459.67 : -273.15;
+        if (value < minimum)
+            throw new Error("Temperature must be at or above absolute zero (-273.15 Celsius / 0 Kelvin).");
+        base = Math.max(-273.15, base);
+    }
+    const result = from === to ? value : target.fromBase(base);
+    if (!Number.isFinite(result) || !Number.isFinite(base))
+        throw new Error("The conversion exceeds the numeric range. Use a smaller value.");
+    return formatCalculatorNumber(result);
+}

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "simplyutils-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.2",
+  "description": "MCP server with everyday developer and text tools from SimplyUtils: JSON formatter, QR codes, unit converter, passwords, UUIDs, hashes, Base64, regex tester, timestamps and word counts.",
+  "main": "dist/server.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/http.js",
+    "start:stdio": "node dist/stdio.js",
+    "test": "node --import tsx --test test/*.test.ts"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "chatgpt",
+    "json",
+    "qr-code",
+    "unit-converter",
+    "developer-tools"
+  ],
+  "author": "Memegician LLC (https://simplyutils.com)",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "express": "^5.3.0",
+    "express-rate-limit": "^8.7.1",
+    "qrcode": "^1.5.4",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.6.5",
+    "@types/qrcode": "^1.5.6",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2"
+  },
+  "bin": {
+    "simplyutils-mcp": "dist/stdio.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "homepage": "https://simplyutils.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Notysoty/simplyutils-mcp.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "mcpName": "io.github.Notysoty/simplyutils-mcp"
+}