inspirobot-mcp 1.0.0 → 1.0.1

package/README.md

@@ -16,3 +16,22 @@ npm install
 npm run build
 node dist/index.js
 ```
+
+<!-- paywall -->
+## Premium tools
+
+These tools need a license key:
+
+* `generate_styled`
+* `font_matrix`
+
+Buy a key at https://mcp-marketplace.io/server/io-github-mrfentmen-inspirobot-mcp and set it in your MCP client config:
+
+```json
+"env": { "MCP_LICENSE_KEY": "mcp_live_..." }
+```
+
+The key is checked against MCP Marketplace, cached for 24 hours, and keeps
+working offline once one check has succeeded. Every other tool on this server
+stays free.
+<!-- /paywall -->

package/dist/api.js

@@ -13,3 +13,145 @@ 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));
+}
+function kib(bytes) {
+    if (bytes === null)
+        return 'size not reported';
+    return bytes >= 1024 ? `${(bytes / 1024).toFixed(1)} KiB` : `${bytes} B`;
+}
+function numParam(value, min, max, fallback) {
+    const n = Number(value);
+    if (!Number.isFinite(n))
+        return String(fallback);
+    return String(Math.max(min, Math.min(Math.round(n), max)));
+}
+/** Render a poster with the parameters the caller sets, then confirm the returned image is actually live. */
+export async function generateStyled(args) {
+    const inscription = (args.inscription ?? '').trim();
+    if (!inscription)
+        return 'Provide an inscription, for example "Ship it and then chart it".';
+    if (inscription.length > 200)
+        return 'Keep the inscription under 200 characters; the poster generators truncate beyond that.';
+    const params = new URLSearchParams({ generate: 'true', inscription });
+    if (args.font)
+        params.set('font', args.font.trim());
+    if (args.script)
+        params.set('script', args.script.trim());
+    if (args.align !== undefined)
+        params.set('align', numParam(args.align, 0, 3, 0));
+    if (args.lineSpacing !== undefined)
+        params.set('linespacing', numParam(args.lineSpacing, 0, 400, 100));
+    if (args.charSpacing !== undefined)
+        params.set('charspacing', numParam(args.charSpacing, -50, 200, 0));
+    const query = params.toString();
+    const res = await fetch(`${API}?${query}`, { headers: { 'User-Agent': UA }, signal: AbortSignal.timeout(30000) });
+    if (!res.ok)
+        throw new InspiroError(`InspiroBot returned HTTP ${res.status}`);
+    const url = (await res.text()).trim();
+    if (!url.startsWith('http'))
+        throw new InspiroError('InspiroBot returned an unexpected response');
+    const head = await probeImage(url);
+    return [
+        `Generated poster: ${url}`,
+        `Inscription: ${inscription}`,
+        `Parameters sent: ${[...params.entries()].map(([k, v]) => `${k}=${v}`).join(', ')}`,
+        `Image check: HTTP ${head.status}, content type ${head.contentType}, size ${kib(head.bytes)}`,
+        head.bytes !== null && head.bytes < 1000
+            ? 'That is a very small file, so the inscription probably did not render.'
+            : 'The image responded on a follow up request, so the URL is live right now.',
+        `Reproduce with: ${API}?${query}`,
+        `The service falls back to its own defaults for any value it does not recognise, so an unknown font or script name still returns an image rather than an error.`,
+    ].join('\n');
+}
+async function probeImage(url) {
+    try {
+        const res = await fetch(url, { method: 'HEAD', headers: { 'User-Agent': UA }, signal: AbortSignal.timeout(20000) });
+        const length = res.headers.get('content-length');
+        const parsed = length === null ? NaN : Number(length);
+        return {
+            url,
+            status: res.status,
+            contentType: res.headers.get('content-type') ?? 'not reported',
+            bytes: Number.isFinite(parsed) ? parsed : null,
+        };
+    }
+    catch {
+        return { url, status: 0, contentType: 'not reported', bytes: null };
+    }
+}
+async function renderOne(params) {
+    const res = await fetch(`${API}?${params.toString()}`, { headers: { 'User-Agent': UA }, signal: AbortSignal.timeout(30000) });
+    if (!res.ok)
+        throw new InspiroError(`InspiroBot returned HTTP ${res.status}`);
+    const url = (await res.text()).trim();
+    if (!url.startsWith('http'))
+        throw new InspiroError('InspiroBot returned an unexpected response');
+    return url;
+}
+/** The same short inscription across several font names, with each rendered file measured, to see what each name actually produces. */
+export async function fontMatrix(args) {
+    const inscription = (args.inscription ?? 'measure this').trim();
+    if (!inscription)
+        return 'Provide an inscription to render across the fonts.';
+    const fonts = (args.fonts ?? 'cooper,weiss,nw,rw')
+        .split(/[,\s]+/)
+        .map((f) => f.trim())
+        .filter(Boolean)
+        .slice(0, 4);
+    if (!fonts.length)
+        return 'Provide at least one font name.';
+    const rows = [];
+    for (const font of fonts) {
+        const params = new URLSearchParams({ generate: 'true', inscription, font });
+        try {
+            const url = await renderOne(params);
+            rows.push({ font, head: await probeImage(url) });
+        }
+        catch (error) {
+            rows.push({ font, head: null, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    const sizes = rows.filter((r) => r.head?.bytes != null).map((r) => r.head?.bytes);
+    return [
+        `Rendered "${inscription}" across ${fonts.length} font name(s) on InspiroBot`,
+        ...rows.map((r) => r.error
+            ? `- ${r.font}: render failed, ${r.error}`
+            : `- ${r.font}: ${r.head?.url} | HTTP ${r.head?.status}, ${r.head?.contentType}, ${kib(r.head?.bytes ?? null)}`),
+        sizes.length ? `File sizes across the renders: ${Math.min(...sizes)} to ${Math.max(...sizes)} bytes` : 'No render reported a size.',
+        'The service does not reject an unknown font name, it substitutes a default, so a render succeeding is not evidence that the name was honoured. Compare the URLs and sizes rather than trusting the name.',
+    ].join('\n');
+}
+/** 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/license.js

@@ -0,0 +1,79 @@
+// Premium tools on this server need a license key bought from MCP Marketplace.
+// Buyers put the key in their MCP client config as MCP_LICENSE_KEY. Every tool
+// that is not listed in PREMIUM keeps working without a key.
+const SLUG = "inspirobot-mcp";
+// Tools that need a key. Everything else is free.
+const PREMIUM = new Set([
+    "generate_styled",
+    "font_matrix",
+]);
+const BUY_URL = `https://mcp-marketplace.io/server/io-github-mrfentmen-${SLUG}`;
+// The license check calls the marketplace's verify endpoint directly instead of
+// using @mcp_marketplace/license. That SDK sends no `apikey` header, so every
+// check it makes is rejected by Supabase before it reaches the function. The
+// publishable key below is public by design - it ships in mcp-marketplace.io's
+// own JavaScript and only ever reaches their licence check.
+const DEFAULT_VERIFY_URL = "https://virupvwhtkpkjsiskckg.supabase.co/functions/v1/verify-key";
+const PUBLISHABLE_KEY = "sb_publishable_BuqlW96Ke8C_zzJG-LQv1Q_YHi_r_4h";
+const OK_CACHE_MS = 60 * 60 * 1000;
+const BAD_CACHE_MS = 60 * 1000;
+const seen = new Map();
+const REASONS = {
+    missing_key: "no key is set",
+    invalid_format: "that key is not a valid MCP Marketplace key",
+    not_found: "that key was not found",
+    revoked: "that key has been revoked",
+    rotated: "that key was rotated, use your new one",
+    expired: "that key has expired, renew it",
+    rate_limited: "there were too many checks just now, try again shortly",
+    network_error: "the license server could not be reached",
+};
+function blocked(tool, reason) {
+    const why = REASONS[reason] ?? `the license server answered "${reason}"`;
+    return `"${tool}" needs a license key, but ${why}. ` +
+        `Set MCP_LICENSE_KEY in your MCP client config. Get a key: ${BUY_URL}`;
+}
+async function verify(key) {
+    const res = await fetch(process.env.MCP_LICENSE_VERIFY_URL || DEFAULT_VERIFY_URL, {
+        method: "POST",
+        headers: {
+            apikey: PUBLISHABLE_KEY,
+            Authorization: `Bearer ${PUBLISHABLE_KEY}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ key, slug: SLUG }),
+        // an unusable key answers 400 with a JSON body, so read the body either way
+        signal: AbortSignal.timeout(15000),
+    });
+    const data = (await res.json());
+    if (typeof data?.valid !== "boolean")
+        return { valid: false, reason: "unexpected_response" };
+    return data;
+}
+/**
+ * Returns null when the caller may run the tool, or a short message telling
+ * them how to get a key.
+ *
+ * A good key is remembered for an hour, so a busy session does not hit the
+ * license server on every call and keeps working through a brief outage.
+ */
+export async function premiumRequired(tool) {
+    if (!PREMIUM.has(tool))
+        return null;
+    const key = process.env.MCP_LICENSE_KEY;
+    if (!key)
+        return blocked(tool, "missing_key");
+    const hit = seen.get(key);
+    if (hit && Date.now() - hit.at < (hit.valid ? OK_CACHE_MS : BAD_CACHE_MS)) {
+        return hit.valid ? null : blocked(tool, hit.reason ?? "invalid");
+    }
+    let result;
+    try {
+        result = await verify(key);
+    }
+    catch {
+        result = { valid: false, reason: "network_error" };
+    }
+    seen.set(key, { ...result, at: Date.now() });
+    return result.valid ? null : blocked(tool, result.reason ?? "invalid");
+}

package/dist/server.js

@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { generate } from "./api.js";
+import { generate, generateStyled, fontMatrix, inscriptionMetrics } from "./api.js";
+import { premiumRequired } from "./license.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 };
@@ -20,5 +21,54 @@ export function createServer() {
             return textError(error(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) => {
+        // ---- paywall: generate_styled ----
+        const paywallMessage = await premiumRequired("generate_styled");
+        if (paywallMessage)
+            return { content: [{ type: "text", text: paywallMessage }], isError: true };
+        // ---- paywall: end ----
+        try {
+            return text(await generateStyled(args));
+        }
+        catch (e) {
+            return textError(error(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) => {
+        // ---- paywall: font_matrix ----
+        const paywallMessage = await premiumRequired("font_matrix");
+        if (paywallMessage)
+            return { content: [{ type: "text", text: paywallMessage }], isError: true };
+        // ---- paywall: end ----
+        try {
+            return text(await fontMatrix(args));
+        }
+        catch (e) {
+            return textError(error(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(error(e));
+        }
+    });
     return server;
 }

package/package.json

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