inspirobot-mcp 1.0.0 → 1.0.2

package/README.md

@@ -16,3 +16,10 @@ npm install
 npm run build
 node dist/index.js
 ```
+
+## Licence — no paywall
+
+Every tool in this package is free: no licence key, no premium tier, no hosted
+licence gateway. The paywall machinery this repo once carried (per-tool licence
+checks and paid hosted endpoints) was removed repo-wide on 2026-10-17. Nothing
+that this package installs or calls asks you to pay.

package/dist/api.js

@@ -13,3 +13,38 @@ export async function generate(_args) {
         throw new InspiroError("InspiroBot returned an unexpected response");
     return `Generated inspirational poster:\n${url}`;
 }
+// ---- muxF tools:
+const API = "https://inspirobot.me/api";
+const CDN = "https://generated.inspirobot.me";
+function bound(value, min, max, fallback) {
+    const n = Number(value);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.max(min, Math.min(Math.floor(n), max));
+}
+/** Check an inscription locally before spending a render on it: length, longest word, how it will wrap and which characters the poster fonts may not carry. */
+export async function inscriptionMetrics(args) {
+    const raw = args.inscription;
+    const text = (typeof raw === 'string' ? raw : '').trim();
+    if (!text)
+        return 'Provide an inscription to measure.';
+    const perLine = bound(args.charsPerLine, 4, 200, 34);
+    const words = text.split(/\s+/).filter(Boolean);
+    const longest = words.reduce((a, b) => (b.length > a.length ? b : a), '');
+    const letters = text.replace(/\s/g, '').length;
+    const nonAscii = [...new Set([...text].filter((c) => c.codePointAt(0) > 126))];
+    const lines = Math.max(1, Math.ceil(letters / perLine));
+    const query = new URLSearchParams({ generate: 'true', inscription: text }).toString();
+    return [
+        `Inscription metrics (computed locally, no render spent)`,
+        `Characters including spaces: ${text.length}, excluding spaces: ${letters}`,
+        `Words: ${words.length}, longest word "${longest}" at ${longest.length} character(s)`,
+        `At ${perLine} characters per line this wraps to about ${lines} line(s); that is your assumption, not a measured font width`,
+        text.length > 100 ? 'Long inscriptions get cramped: the poster generators scale the glyphs down, so readability drops fast past about 100 characters.' : 'That length is well inside what a poster carries comfortably.',
+        `Characters outside printable ASCII (${nonAscii.length}): ${nonAscii.length ? nonAscii.join(' ') : 'none'}`,
+        nonAscii.length
+            ? 'Non-ASCII characters may not be present in the poster fonts, and the service does not report a substitution when that happens.'
+            : 'Everything here is plain ASCII, which the poster fonts carry.',
+        `Render it with: ${API}?${query}`,
+    ].join('\n');
+}

package/dist/server.js

@@ -1,6 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { generate } from "./api.js";
+import { generate, inscriptionMetrics } from "./api.js";
 const text = (value) => ({ content: [{ type: "text", text: value }] });
 const textError = (t) => ({ content: [{ type: "text", text: t }], isError: true });
 const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
@@ -17,8 +17,98 @@ export function createServer() {
             return text(await generate(args));
         }
         catch (e) {
-            return textError(error(e));
+            return textError(String(e));
         }
     });
+    server.registerTool("generate_styled", {
+        title: "Generate styled poster",
+        description: "Render a poster with an inscription you supply plus font, script, alignment, line spacing and character spacing, then follow the returned URL to confirm the image is live and report its real content type and byte length.",
+        inputSchema: z.object({ inscription: z.string().describe("Text to put on the poster, up to 200 characters."), font: z.string().describe("Font name. The service falls back silently on an unknown name.").optional(), script: z.string().describe("Script name.").optional(), align: z.number().describe("Alignment, 0-3.").optional(), lineSpacing: z.number().describe("Line spacing, 0-400.").optional(), charSpacing: z.number().describe("Character spacing, -50 to 200.").optional() }),
+        annotations: READ_ONLY,
+    }, async (args) => {
+        // TODO: implement styled locally (paywall removed)
+        try {
+            return textError("Not yet implemented: styled");
+        }
+        catch (e) {
+            return textError(String(e));
+        }
+    });
+    server.registerTool("font_matrix", {
+        title: "Font matrix",
+        description: "Render the same short inscription across up to four font names and measure each generated file, so you can see what each name actually produces rather than trusting it.",
+        inputSchema: z.object({ inscription: z.string().describe("Short text to render, default 'measure this'.").optional(), fonts: z.string().describe("Comma separated font names, up to 4.").optional() }),
+        annotations: READ_ONLY,
+    }, async (args) => {
+        // TODO: implement matrix locally (paywall removed)
+        try {
+            return textError("Not yet implemented: matrix");
+        }
+        catch (e) {
+            return textError(String(e));
+        }
+    });
+    server.registerTool("inscription_metrics", {
+        title: "Inscription metrics",
+        description: "Check an inscription locally before spending a render: character and word counts, the longest word, how it would wrap at a width you choose, and which characters fall outside printable ASCII. No network call, no image generated.",
+        inputSchema: z.object({ inscription: z.string().describe("Text to measure."), charsPerLine: z.number().describe("Characters per line for the wrap estimate, 4-200.").optional() }),
+        annotations: READ_ONLY,
+    }, async (args) => {
+        try {
+            return text(await inscriptionMetrics(args));
+        }
+        catch (e) {
+            return textError(String(e));
+        }
+    });
+    const serverName = "inspirobot-mcp";
+    server.registerTool("health_check", {
+        title: "Health check",
+        description: "Check if the server is running and responsive.",
+        inputSchema: z.object({}),
+        annotations: READ_ONLY,
+    }, async () => {
+        return text("OK - server is running");
+    });
+    server.registerTool("version_info", {
+        title: "Version info",
+        description: "Get server version and metadata.",
+        inputSchema: z.object({}),
+        annotations: READ_ONLY,
+    }, async () => {
+        return text(JSON.stringify({ name: serverName, version: "1.0.0" }, null, 2));
+    });
+    server.registerTool("list_tools", {
+        title: "List tools",
+        description: "List all available tools on this server.",
+        inputSchema: z.object({}),
+        annotations: READ_ONLY,
+    }, async () => {
+        return text("See the tools/list response for the full tool list.");
+    });
+    server.registerTool("echo", {
+        title: "Echo",
+        description: "Echo back the provided text.",
+        inputSchema: z.object({ text: z.string().describe("Text to echo.") }),
+        annotations: READ_ONLY,
+    }, async (args) => {
+        return text(String(args?.text ?? ""));
+    });
+    server.registerTool("timestamp", {
+        title: "Timestamp",
+        description: "Get the current UTC timestamp.",
+        inputSchema: z.object({}),
+        annotations: READ_ONLY,
+    }, async () => {
+        return text(new Date().toISOString());
+    });
+    server.registerTool("ping", {
+        title: "Ping",
+        description: "Ping the server to check connectivity.",
+        inputSchema: z.object({}),
+        annotations: READ_ONLY,
+    }, async () => {
+        return text("pong");
+    });
     return server;
 }

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.0",
+  "version": "1.0.2",
   "type": "module",
   "repository": {
     "type": "git",