onesignal-mcp 1.0.3 → 1.1.0

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,6 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { listApps, getApp, listNotifications, pushSdkPopularity } from "./api.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 };
@@ -75,9 +75,8 @@ export function createServer() {
         }),
         annotations: READ_ONLY,
     }, async (args) => {
-        // TODO: implement timeline locally (paywall removed)
         try {
-            return textError("Not yet implemented: timeline");
+            return text(await sdkReleaseTimeline(args));
         }
         catch (e) {
             return textError(String(e));
@@ -89,9 +88,8 @@ export function createServer() {
         inputSchema: z.object({ limit: z.number().describe("How many incidents to show, 1-15.").optional() }),
         annotations: READ_ONLY,
     }, async (args) => {
-        // TODO: implement status locally (paywall removed)
         try {
-            return textError("Not yet implemented: status");
+            return text(await platformStatus(args));
         }
         catch (e) {
             return textError(String(e));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onesignal-mcp",
-  "version": "1.0.3",
+  "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",