onesignal-mcp 1.0.2 → 1.1.0

package/README.md

@@ -12,21 +12,9 @@ Query the OneSignal API (free tier; use a current v2 Organization API key for ON
 
 [onesignal-mcp](https://github.com/mrfentmen/premium-mcps/tree/main/servers/onesignal-mcp)
 
-<!-- paywall -->
-## Premium tools
+## Licence — no paywall
 
-These tools need a licence key:
-
-* `sdk_release_timeline`
-* `platform_status`
-
-The tool bodies run on our gateway, not inside this package, so the key is what buys access. Buy one at https://buy.polar.sh/polar_cl_mrO7rS5LZxpqM7oAFFEA10i9121J240U40IIj4JRZO4 and set it in your MCP client config:
-
-```json
-"env": { "MCP_LICENSE_KEY": "polar_..." }
-```
-
-The gateway checks the key against Polar and gives every key 1,000 free premium
-calls a month before per-call billing starts. Every other tool on this server
-stays free.
-<!-- /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

@@ -71,6 +71,139 @@ async function onesignalWeeklyDownloads(pkg) {
         return null;
     }
 }
+/** OneSignal's public status page, a Statuspage instance. */
+const ONESIGNAL_STATUS = "https://status.onesignal.com/api/v2";
+async function onesignalStatusJson(path) {
+    const url = `${ONESIGNAL_STATUS}${path}`;
+    const res = await fetch(url, {
+        headers: { "User-Agent": "awesome-mcps/1.0", Accept: "application/json" },
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!res.ok)
+        throw new OneSignalError(`The status page returned ${res.status} for ${path.replace(/^\//, "")}.`);
+    return (await res.json());
+}
+function osDays(fromIso, toMs = Date.now()) {
+    const t = Date.parse(fromIso);
+    if (!Number.isFinite(t))
+        return null;
+    return Math.round((toMs - t) / 86400000);
+}
+function osDay(iso) {
+    const t = Date.parse(iso ?? "");
+    return Number.isFinite(t) ? new Date(t).toISOString().slice(0, 10) : "unknown";
+}
+function osSpan(ms) {
+    if (!Number.isFinite(ms))
+        return "unresolved";
+    if (ms < 0)
+        return "0 min (the page's own timestamps are out of order)";
+    const mins = Math.round(ms / 60000);
+    if (mins < 60)
+        return `${mins} min`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 48)
+        return `${hours} h ${mins % 60} min`;
+    return `${Math.round(hours / 24)} day(s)`;
+}
+/** Release cadence of one OneSignal SDK, read from the npm packument's own time map. */
+export async function sdkReleaseTimeline(args) {
+    const requested = String(args.package ?? "").trim();
+    const pkg = requested || "react-native-onesignal";
+    const limit = Math.min(Math.max(Number(args.limit ?? 10) || 10, 1), 30);
+    const doc = await onesignalJson(`${ONESIGNAL_NPM}/${encodeURIComponent(pkg)}`);
+    const time = doc.time ?? {};
+    const versions = Object.keys(doc.versions ?? {});
+    if (!versions.length)
+        throw new OneSignalError(`${pkg} has no published versions on npm.`);
+    const dated = versions
+        .map((v) => ({ version: v, at: time[v] }))
+        .filter((r) => typeof r.at === "string")
+        .sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+    if (!dated.length)
+        throw new OneSignalError(`npm published no dates for ${pkg}, so the cadence cannot be read.`);
+    const first = dated[0];
+    const latestTag = doc["dist-tags"]?.latest ?? null;
+    const latestDated = dated[dated.length - 1];
+    const gaps = [];
+    for (let i = 1; i < dated.length; i++)
+        gaps.push(Date.parse(dated[i].at) - Date.parse(dated[i - 1].at));
+    const sortedGaps = [...gaps].sort((a, b) => a - b);
+    const medianGap = sortedGaps.length
+        ? sortedGaps.length % 2
+            ? sortedGaps[(sortedGaps.length - 1) / 2]
+            : (sortedGaps[sortedGaps.length / 2 - 1] + sortedGaps[sortedGaps.length / 2]) / 2
+        : null;
+    const tags = Object.entries(doc["dist-tags"] ?? {}).map(([tag, version]) => ({
+        tag,
+        version,
+        at: time[version],
+        prerelease: /-(alpha|beta|rc|next|pre|dev|canary|staging)/i.test(String(version)),
+    }));
+    const prereleaseTags = tags.filter((t) => t.prerelease);
+    const recent = [...dated].reverse().slice(0, limit);
+    const rows = [
+        `${pkg} release train, from the npm registry`, 
+        `  versions published     ${versions.length}`,
+        `  first release          ${osDay(first.at)} (${first.version})`,
+        `  latest tag             ${latestTag ?? "not set"}${latestTag && time[latestTag] ? `, published ${osDay(time[latestTag])}` : ""}`,
+        `  newest version by date ${latestDated.version}, ${osDay(latestDated.at)}`,
+        `  days since a release   ${osDays(latestDated.at) ?? "unknown"}`,
+        medianGap !== null ? `  median gap             ${(medianGap / 86400000).toFixed(1)} day(s)` : "",
+        "",
+        `dist-tags (${tags.length}):`,
+        ...tags.map((t) => `  ${t.tag.padEnd(14)} ${t.version}${t.at ? ` — ${osDay(t.at)}` : ""}${t.prerelease ? " (prerelease)" : ""}`),
+        prereleaseTags.length
+            ? `  ${prereleaseTags.length} tag(s) still point at a prerelease: ${prereleaseTags.map((t) => t.tag).join(", ")}`
+            : "  No tag points at a prerelease.",
+        "",
+        `Most recent ${recent.length} version(s) by publish date:`,
+        ...recent.map((r) => `  ${osDay(r.at)}  ${r.version}`),
+        "",
+        "Dates are npm's own publish timestamps. A version republished under a new tag keeps its original date.",
+    ].filter(Boolean);
+    return rows.join("\n");
+}
+/** OneSignal's own reliability record: current state per product area plus incident history. */
+export async function platformStatus(args) {
+    const limit = Math.min(Math.max(Number(args.limit ?? 10) || 10, 1), 25);
+    const [summary, history] = await Promise.all([
+        onesignalStatusJson("/summary.json"),
+        onesignalStatusJson("/incidents.json").catch(() => ({ incidents: [] })),
+    ]);
+    const state = summary.status ?? {};
+    const components = Array.isArray(summary.components) ? summary.components : [];
+    const incidents = Array.isArray(history.incidents) ? history.incidents : Array.isArray(summary.incidents) ? summary.incidents : [];
+    const ranked = [...incidents]
+        .sort((a, b) => Date.parse(b.created_at ?? 0) - Date.parse(a.created_at ?? 0))
+        .slice(0, limit);
+    const rows = [
+        `OneSignal platform status — ${String(state.description ?? "unknown")} (indicator: ${String(state.indicator ?? "none")})`,
+        "",
+        `Product areas (${components.length}):`,
+        ...components.map((c) => `  ${String(c.status ?? "unknown").padEnd(12)} ${c.name}${c.group ? ` — ${c.group}` : ""}`),
+    ];
+    if (!components.length)
+        rows.push("  The status page published no components.");
+    rows.push("", `Incident history (${incidents.length} on record, latest ${ranked.length} shown):`);
+    if (!ranked.length)
+        rows.push("  No incidents on record.");
+    for (const inc of ranked) {
+        const resolved = inc.resolved_at ?? (inc.status === "resolved" ? inc.updated_at : null);
+        const createdMs = Date.parse(inc.created_at ?? "");
+        const resolvedMs = resolved ? Date.parse(resolved) : NaN;
+        const took = Number.isFinite(createdMs) && Number.isFinite(resolvedMs) ? resolvedMs - createdMs : NaN;
+        const updates = Array.isArray(inc.incident_updates) ? inc.incident_updates : [];
+        const latest = updates[0] ?? null;
+        rows.push(`  ${osDay(inc.created_at)}  ${inc.name}`);
+        const duration = !resolved ? "still open" : Number.isFinite(took) ? `resolved in ${osSpan(took)}` : "resolved, duration not published";
+        rows.push(`    impact ${String(inc.impact ?? "none")} | status ${String(inc.status ?? "unknown")} | ${duration}${inc.shortlink ? ` | ${inc.shortlink}` : ""}`);
+        if (latest)
+            rows.push(`    latest update (${osDay(latest.created_at)}): ${String(latest.body ?? "").replace(/\s+/g, " ").slice(0, 240)}`);
+    }
+    rows.push("", "Read from status.onesignal.com, the vendor's own Statuspage. Incident text is theirs, not a measurement of this server.");
+    return rows.join("\n");
+}
 /** Which OneSignal SDK people actually install, and how big each one is. */
 export async function pushSdkPopularity(_args) {
     const docs = await Promise.all(ONESIGNAL_SDKS.map(async (pkg) => {

package/dist/server.js

@@ -1,7 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { errorMessage, listApps, getApp, listNotifications, pushSdkPopularity } from "./api.js";
-import { premiumTool } from "./gateway.js";
+import { listApps, getApp, listNotifications, pushSdkPopularity, sdkReleaseTimeline, platformStatus } from "./api.js";
 const text = (t) => ({ content: [{ type: "text", text: t }] });
 const textError = (t) => ({ content: [{ type: "text", text: t }], isError: true });
 const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
@@ -20,7 +19,7 @@ export function createServer() {
             return text(await listApps());
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
     server.registerTool("get_app", {
@@ -35,7 +34,7 @@ export function createServer() {
             return text(await getApp(app_id));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
     server.registerTool("list_notifications", {
@@ -51,7 +50,7 @@ export function createServer() {
             return text(await listNotifications(app_id, limit));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
     server.registerTool("push_sdk_popularity", {
@@ -64,7 +63,7 @@ export function createServer() {
             return text(await pushSdkPopularity(_args));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
     server.registerTool("sdk_release_timeline", {
@@ -76,14 +75,11 @@ export function createServer() {
         }),
         annotations: READ_ONLY,
     }, async (args) => {
-        // ---- paywall: sdk_release_timeline ----
-        // The body runs on the gateway, behind the licence gate.
-        // ---- paywall: end ----
         try {
-            return text(await premiumTool("mcp_onesignal_sdk_release_timeline", args));
+            return text(await sdkReleaseTimeline(args));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
     server.registerTool("platform_status", {
@@ -92,15 +88,45 @@ export function createServer() {
         inputSchema: z.object({ limit: z.number().describe("How many incidents to show, 1-15.").optional() }),
         annotations: READ_ONLY,
     }, async (args) => {
-        // ---- paywall: platform_status ----
-        // The body runs on the gateway, behind the licence gate.
-        // ---- paywall: end ----
         try {
-            return text(await premiumTool("mcp_onesignal_platform_status", args));
+            return text(await platformStatus(args));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
+    const serverName = "onesignal-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 ?? ""));
+    });
     return server;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onesignal-mcp",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Query the OneSignal API (free tier; use a current v2 Organization API key for ONESIGNAL_USER_KEY and the app REST API key for ONESIGNAL_APP_KEY, Basic auth).",
   "type": "module",
   "mcpName": "io.github.mrfentmen/onesignal-mcp",

package/dist/gateway.d.ts

@@ -1,16 +0,0 @@
-/**
- * Thin client for the premium gateway.
- *
- * The premium tools do not run in this package any more. Their bodies live on
- * the gateway, which checks a Polar licence key before it does any work, so
- * deleting anything here buys nothing: the answer only exists behind the gate.
- *
- * Set `MCP_LICENSE_KEY` to a Polar licence key. `MCP_GATEWAY_URL` overrides the
- * endpoint, which is only useful for testing.
- */
-/** Raised when a premium call cannot be completed. `message` is safe to show. */
-export declare class GatewayError extends Error {
-    readonly refused: boolean;
-    constructor(message: string, refused: boolean);
-}
-export declare function premiumTool(tool: string, args: Record<string, unknown>): Promise<string>;

package/dist/gateway.js

@@ -1,85 +0,0 @@
-/**
- * Thin client for the premium gateway.
- *
- * The premium tools do not run in this package any more. Their bodies live on
- * the gateway, which checks a Polar licence key before it does any work, so
- * deleting anything here buys nothing: the answer only exists behind the gate.
- *
- * Set `MCP_LICENSE_KEY` to a Polar licence key. `MCP_GATEWAY_URL` overrides the
- * endpoint, which is only useful for testing.
- */
-const DEFAULT_GATEWAY_URL = 'https://mcp-gateway.contactae2000.workers.dev/mcp';
-const DEFAULT_TIMEOUT_MS = 25000;
-const USER_AGENT = 'mrfentmen-mcp/1.0';
-/** Raised when a premium call cannot be completed. `message` is safe to show. */
-export class GatewayError extends Error {
-    refused;
-    constructor(message, refused) {
-        super(message);
-        this.refused = refused;
-        this.name = 'GatewayError';
-    }
-}
-export async function premiumTool(tool, args) {
-    const key = (process.env.MCP_LICENSE_KEY ?? '').trim();
-    if (!key) {
-        throw new GatewayError(`"${tool}" is a premium tool and no licence key is set. Set MCP_LICENSE_KEY in your MCP client config.`, true);
-    }
-    const url = (process.env.MCP_GATEWAY_URL ?? DEFAULT_GATEWAY_URL).trim();
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
-    let response;
-    try {
-        response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'content-type': 'application/json',
-                accept: 'application/json',
-                'user-agent': USER_AGENT,
-                authorization: `Bearer ${key}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'tools/call',
-                params: { name: tool, arguments: args },
-            }),
-            signal: controller.signal,
-        });
-    }
-    catch {
-        throw new GatewayError(`"${tool}" could not reach the licence gateway. Check your connection and try again.`, false);
-    }
-    finally {
-        clearTimeout(timer);
-    }
-    if (!response.ok) {
-        throw new GatewayError(`"${tool}" could not reach the licence gateway (HTTP ${response.status}).`, false);
-    }
-    let body;
-    try {
-        body = (await response.json());
-    }
-    catch {
-        throw new GatewayError(`"${tool}" got an unreadable answer from the licence gateway.`, false);
-    }
-    if (body.error) {
-        throw new GatewayError(`"${tool}" was refused by the licence gateway: ${body.error.message ?? 'unknown error'}`, false);
-    }
-    const result = body.result ?? {};
-    const text = (result.content ?? [])
-        .map((part) => part.text ?? '')
-        .join('\n')
-        .trim();
-    if (result.isError) {
-        // The gateway marks a licence refusal structurally, so a missing or rejected
-        // key is told apart from a tool that failed after the gate let it through.
-        if (result.structuredContent?.licenceRefusal) {
-            throw new GatewayError(text || `"${tool}" needs a valid licence key.`, true);
-        }
-        throw new GatewayError(text || `"${tool}" failed on the licence gateway.`, false);
-    }
-    if (!text)
-        throw new GatewayError(`"${tool}" returned no data.`, false);
-    return text;
-}

package/dist/license.d.ts

@@ -1,8 +0,0 @@
-/**
- * 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 declare function premiumRequired(tool: string): Promise<string | null>;