tides-mcp 1.0.1 → 1.0.3

package/README.md

@@ -18,45 +18,3 @@ node dist/index.js
 ```
 
 The server uses stdio MCP transport and does not write files or contact any service other than NOAA.
-
-## Quick start
-
-```bash
-npm install
-npm run build
-node dist/index.js
-```
-
-The server uses stdio, so it can be connected to Claude Desktop, Cursor, VS Code, MCP Inspector, or another compatible MCP client.
-
-## Tools at a glance
-
-- `get_tide_predictions`: Get NOAA high low or hourly tide predictions for a station and date range.
-- `get_water_levels`: Get observed NOAA water levels for a station and short date range.
-
-## Limits and privacy
-
-This project is intentionally narrow. It should be treated as a practical helper, not a complete certification or security audit. Check the implementation and the returned data before using it with sensitive material. No credentials are required unless the project explicitly says otherwise.
-
-## Try it
-
-After building, connect the server through your MCP client. The repository root also contains `smoke-test.mjs` for projects covered by the shared harness. A typical tool call starts with `get_tide_predictions`.
-
-<!-- paywall -->
-## Premium tools
-
-These tools need a license key:
-
-* `station_metadata`
-* `harmonic_constituents`
-
-Buy a key at https://mcp-marketplace.io/server/io-github-mrfentmen-tides-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.d.ts

@@ -3,20 +3,15 @@ export declare class TidesError extends Error {
 export declare function predictions(station: string, begin: string, end: string, interval?: "hilo" | "h", units?: string): Promise<any>;
 export declare function waterLevels(station: string, begin: string, end: string, interval?: string, units?: string): Promise<any>;
 export declare function format(data: any): string;
-/** What a NOAA station is and what it publishes: identity, position, tide type, and the product families it carries. */
-export declare function stationMetadata(args: {
-    station?: string;
+export declare function stationList(a: {
+    state?: string;
 }): Promise<string>;
-/** The harmonic constants behind a station's tide: which constituents dominate, and whether the tide is semidiurnal, mixed or diurnal. */
-export declare function harmonicConstituents(args: {
-    station?: string;
-    units?: string;
-    limit?: number;
+export declare function stationMetadata(a: {
+    station: string;
 }): Promise<string>;
-/** What a set of high and low predictions adds up to: the tidal range, mean high and low water, and the biggest range in the window. */
-export declare function tideStatistics(args: {
-    station?: string;
-    begin?: string;
-    end?: string;
-    units?: string;
+export declare function tideRange(a: {
+    station: string;
+    begin: string;
+    end: string;
+    units: string;
 }): Promise<string>;

package/dist/api.js

@@ -8,137 +8,58 @@ async function get(params) { const url = new URL(BASE); Object.entries({ ...para
 export function predictions(station, begin, end, interval = "hilo", units = "english") { return get({ station, product: "predictions", datum: "MLLW", begin_date: begin.replaceAll("-", ""), end_date: end.replaceAll("-", ""), interval, units }); }
 export function waterLevels(station, begin, end, interval = "6", units = "english") { return get({ station, product: "water_level", datum: "MLLW", begin_date: begin.replaceAll("-", ""), end_date: end.replaceAll("-", ""), interval, units }); }
 export function format(data) { return JSON.stringify(data, null, 2).slice(0, 12000); }
-// ---- muxF tools:
-const METADATA = "https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/stations";
-async function metaGet(url) {
-    const res = await fetch(url, { headers: HEADERS, signal: AbortSignal.timeout(20000) });
-    if (res.status === 404)
-        throw new TidesError("NOAA has no record at that address.");
+const MD = "https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi";
+async function metadata(path) {
+    const res = await fetch(MD + path, { headers: HEADERS, signal: AbortSignal.timeout(20000) });
     if (!res.ok)
-        throw new TidesError(`NOAA error ${res.status}`);
-    const data = (await res.json());
-    if (data?.error)
-        throw new TidesError(data.error.message ?? "NOAA returned an error");
-    return data;
+        throw new TidesError(`NOAA metadata error ${res.status}`);
+    return res.json();
 }
-function clean(station) {
-    const value = (station ?? "").trim();
-    if (!/^[A-Za-z0-9]{7,12}$/.test(value))
-        throw new TidesError(`Not a NOAA station id: "${station}". Use the 7 or 8 digit station number.`);
-    return value;
-}
-function yesNo(value) {
-    if (value === undefined)
-        return "not reported";
-    return value ? "yes" : "no";
-}
-/** What a NOAA station is and what it publishes: identity, position, tide type, and the product families it carries. */
-export async function stationMetadata(args) {
-    const id = clean(args.station ?? "");
-    const data = await metaGet(`${METADATA}/${encodeURIComponent(id)}.json`);
-    const s = data.stations?.[0];
-    if (!s)
-        throw new TidesError(`NOAA has no station with id ${id}.`);
-    const products = [
-        ["Tide predictions", yesNo(s.forecast)],
-        ["Observed water levels", yesNo(s.observedst)],
-        ["Flood levels", yesNo(s.floodlevels)],
-        ["Inundation database", yesNo(s.inundationdb)],
-        ["Storm surge outlooks", yesNo(s.outlook)],
-        ["Storm surge products", yesNo(s.stormsurge)],
-        ["Historical tide factors", yesNo(s.HTFhistorical)],
-        ["Monthly mean tides", yesNo(s.HTFmonthly)],
-    ];
-    const available = products.filter(([, v]) => v === "yes").map(([k]) => k);
-    return [
-        `NOAA station ${s.id ?? id}: ${s.name ?? "name not reported"}${s.state ? `, ${s.state}` : ""}`,
-        `Position: ${s.lat === undefined ? "not reported" : s.lat}, ${s.lng === undefined ? "not reported" : s.lng}`,
-        `Tidal station: ${yesNo(s.tidal)}${s.greatlakes ? " (Great Lakes station)" : ""}`,
-        `Tide type: ${s.tideType ?? "not reported"}`,
-        `Local time zone: ${s.timezone ?? "not reported"}${s.timezonecorr === undefined ? "" : ` (offset ${s.timezonecorr} hours from GMT)`}`,
-        `SHEF code: ${s.shefcode ?? "not reported"}`,
-        `Port code: ${s.portscode ? s.portscode : "none reported"}`,
-        `Affiliations: ${s.affiliations ? s.affiliations : "none reported"}`,
-        `Marked non-navigational: ${yesNo(s.nonNavigational)}`,
-        `Data product families published (${available.length} of ${products.length}): ${available.join(", ") || "none reported"}`,
-    ].join("\n");
-}
-/** The harmonic constants behind a station's tide: which constituents dominate, and whether the tide is semidiurnal, mixed or diurnal. */
-export async function harmonicConstituents(args) {
-    const id = clean(args.station ?? "");
-    const units = args.units === "metric" ? "metric" : "english";
-    const limit = Math.max(1, Math.min(Math.floor(args.limit ?? 10), 30));
-    const data = await metaGet(`${METADATA}/${encodeURIComponent(id)}/harcon.json?units=${units}`);
-    const rows = data.HarmonicConstituents ?? [];
+export async function stationList(a) {
+    const data = await metadata("/stations.json?type=tidepredictions");
+    const all = Array.isArray(data?.stations) ? data.stations : [];
+    const wanted = a.state ? a.state.trim().toUpperCase() : "";
+    const rows = wanted ? all.filter((s) => clean(s?.state).toUpperCase() === wanted) : all;
     if (!rows.length)
-        throw new TidesError(`NOAA publishes no harmonic constituents for station ${id}.`);
-    const unitLabel = data.units === "metric" ? "metres" : "feet";
-    const byName = new Map(rows.map((r) => [String(r.name ?? ""), r]));
-    const amplitude = (name) => Number(byName.get(name)?.amplitude ?? 0);
-    const m2 = amplitude("M2");
-    const s2 = amplitude("S2");
-    const k1 = amplitude("K1");
-    const o1 = amplitude("O1");
-    const form = m2 + s2 > 0 ? (k1 + o1) / (m2 + s2) : NaN;
-    const kind = !Number.isFinite(form) ? "not classifiable, no semidiurnal energy reported" : form < 0.5 ? "predominantly semidiurnal" : form <= 2 ? "mixed mainly semidiurnal" : "predominantly diurnal";
-    const ranked = [...rows].sort((a, b) => (Number(b.amplitude) || 0) - (Number(a.amplitude) || 0));
-    const principal = ["M2", "S2", "K1", "O1"].filter((n) => byName.has(n));
-    return [
-        `Harmonic constituents at NOAA station ${id}, amplitudes in ${unitLabel}`,
-        `Constituents on file: ${rows.length}`,
-        `Form number F = (K1+O1)/(M2+S2) = ${Number.isFinite(form) ? form.toFixed(3) : "not reported"}, so the tide is ${kind}`,
-        principal.length
-            ? `Principal constituents: ${principal.map((n) => `${n} ${amplitude(n)} ${unitLabel} at local phase ${byName.get(n)?.phase_local ?? "not reported"} degrees`).join("; ")}`
-            : "Principal constituents: none of M2, S2, K1 or O1 are on file for this station.",
-        `Strongest ${Math.min(limit, ranked.length)} by amplitude:`,
-        ...ranked.slice(0, limit).map((c) => `- ${c.name ?? "unnamed"}: ${c.amplitude === undefined ? "amplitude not reported" : c.amplitude} ${unitLabel}, local phase ${c.phase_local ?? "not reported"} degrees, speed ${c.speed ?? "not reported"} deg/h, ${c.description ?? "no description"}`),
-        ranked.length > limit ? `... and ${ranked.length - limit} more constituent(s).` : "",
-    ].filter(Boolean).join("\n");
+        return `NOAA lists no tide stations${wanted ? ` in ${wanted}` : ""}.`;
+    return [`${rows.length} tide station(s)${wanted ? ` in ${wanted}` : ""}, showing ${Math.min(rows.length, 40)}:`, "",
+        ...rows.slice(0, 40).map((s, i) => `${i + 1}. ${clean(s?.name)} · ${clean(s?.id)} · ${clean(s?.state)} · ${s?.lat}, ${s?.lng}`)].join("\n");
+}
+export async function stationMetadata(a) {
+    const id = clean(a.station);
+    if (!/^[A-Za-z0-9]{5,10}$/.test(id))
+        throw new TidesError(`"${id}" is not a NOAA station id`);
+    const body = await metadata(`/stations/${encodeURIComponent(id)}.json`);
+    const s = Array.isArray(body?.stations) ? body.stations[0] : undefined;
+    if (!s?.id)
+        throw new TidesError(`No NOAA station ${id}`);
+    return [`${clean(s.name)} (${clean(s.id)})`, "",
+        `State: ${clean(s.state)}`,
+        `Affiliation: ${clean(s.affiliation)}`,
+        `Coordinates: ${s.lat}, ${s.lng}`,
+        `Time zone: ${clean(s.timezone)} ${clean(s.timezonecorr)}`,
+        `Tide predictions: ${s.tideType ? "yes" : "no"}`,
+        `Products: ${Array.isArray(s.products) ? s.products.slice(0, 8).map((p) => clean(p.name)).join(", ") : ""}`,
+        `Station page: https://tidesandcurrents.noaa.gov/stationhome.html?id=${clean(s.id)}`].join("\n");
 }
-/** What a set of high and low predictions adds up to: the tidal range, mean high and low water, and the biggest range in the window. */
-export async function tideStatistics(args) {
-    const begin = (args.begin ?? "").trim();
-    const end = (args.end ?? "").trim();
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(begin) || !/^\d{4}-\d{2}-\d{2}$/.test(end)) {
-        throw new TidesError("Give both dates as YYYY-MM-DD.");
-    }
-    if (end < begin)
-        throw new TidesError("The end date must not be before the begin date.");
-    const units = args.units === "metric" ? "metric" : "english";
-    const data = await predictions(String(args.station ?? "").trim(), begin, end, "hilo", units);
-    const rows = [];
-    for (const r of (data.predictions ?? [])) {
-        const v = Number(r.v);
-        if (!Number.isFinite(v))
-            continue;
-        rows.push({ t: String(r.t ?? "time not reported"), v, type: String(r.type ?? "?") });
-    }
+export async function tideRange(a) {
+    const id = clean(a.station);
+    if (!/^[A-Za-z0-9]{5,10}$/.test(id))
+        throw new TidesError(`"${id}" is not a NOAA station id`);
+    const data = await predictions(id, a.begin, a.end, "hilo", a.units);
+    const rows = Array.isArray(data?.predictions) ? data.predictions : [];
     if (!rows.length)
-        throw new TidesError("NOAA returned no high or low predictions for that station and window.");
-    const highs = rows.filter((r) => r.type.toUpperCase().startsWith("H"));
-    const lows = rows.filter((r) => r.type.toUpperCase().startsWith("L"));
-    const unitLabel = units === "metric" ? "m" : "ft";
-    const mean = (values) => (values.length ? (values.reduce((a, b) => a + b, 0) / values.length).toFixed(3) : "not reported");
-    const highest = highs.length ? highs.reduce((a, b) => (b.v > a.v ? b : a)) : null;
-    const lowest = lows.length ? lows.reduce((a, b) => (b.v < a.v ? b : a)) : null;
-    const biggest = highs.length && lows.length
-        ? highs.reduce((best, h) => {
-            const after = lows.filter((l) => l.t > h.t);
-            const l = after.length ? after.reduce((a, b) => (a.v < b.v ? a : b)) : null;
-            const range = l ? h.v - l.v : -Infinity;
-            return range > best.range ? { high: h, low: l, range } : best;
-        }, { high: null, low: null, range: -Infinity })
-        : { high: null, low: null, range: -Infinity };
-    return [
-        `Tide statistics for station ${String(args.station ?? "").trim()} from ${begin} to ${end}, in ${unitLabel}`,
-        `Predictions returned: ${rows.length} (${highs.length} high, ${lows.length} low)`,
-        `Mean high water: ${mean(highs.map((r) => r.v))} ${unitLabel}`,
-        `Mean low water: ${mean(lows.map((r) => r.v))} ${unitLabel}`,
-        `Mean range: ${mean(highs.map((h) => h.v)) !== "not reported" && mean(lows.map((l) => l.v)) !== "not reported" ? `${(highs.reduce((a, b) => a + b.v, 0) / highs.length - lows.reduce((a, b) => a + b.v, 0) / lows.length).toFixed(3)} ${unitLabel}` : "not reported"}`,
-        `Highest high: ${highest ? `${highest.v} ${unitLabel} at ${highest.t}` : "no high in the window"}`,
-        `Lowest low: ${lowest ? `${lowest.v} ${unitLabel} at ${lowest.t}` : "no low in the window"}`,
-        biggest.range > -Infinity && biggest.high && biggest.low
-            ? `Greatest high to following low: ${biggest.range.toFixed(3)} ${unitLabel}, from ${biggest.high.v} at ${biggest.high.t} to ${biggest.low.v} at ${biggest.low.t}`
-            : "Greatest high to following low: not computable, the window has no matched high and low pair.",
-    ].join("\n");
+        return `No tide predictions for ${id} between ${a.begin} and ${a.end}.`;
+    const values = rows.map((p) => Number(p.v)).filter((v) => Number.isFinite(v));
+    const highs = rows.filter((p) => clean(p.type).toLowerCase() === "h");
+    const lows = rows.filter((p) => clean(p.type).toLowerCase() === "l");
+    const unit = a.units === "metric" ? "m" : "ft";
+    return [`Tide range for ${id} · ${a.begin} to ${a.end}`, "",
+        `Highest: ${Math.max(...values).toFixed(2)} ${unit}`,
+        `Lowest: ${Math.min(...values).toFixed(2)} ${unit}`,
+        `Range: ${(Math.max(...values) - Math.min(...values)).toFixed(2)} ${unit}`,
+        `High tides: ${highs.length} · low tides: ${lows.length}`,
+        `Next high: ${clean(highs[0]?.t) || "n/a"} ${clean(highs[0]?.v)} ${unit}`,
+        `Next low: ${clean(lows[0]?.t) || "n/a"} ${clean(lows[0]?.v)} ${unit}`].join("\n");
 }
+function clean(value) { return String(value ?? "").replace(/\s+/g, " ").trim(); }

package/dist/index.d.ts

@@ -1 +1,2 @@
+#!/usr/bin/env node
 export {};

package/dist/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createServer } from "./server.js";
 async function main() {

package/dist/server.d.ts

@@ -1,4 +1,2 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { TidesError } from "./api.js";
 export declare function createServer(): McpServer;
-export { TidesError };

package/dist/server.js

@@ -1,83 +1,75 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { format, harmonicConstituents, predictions, stationMetadata, tideStatistics, TidesError, waterLevels } from "./api.js";
-import { premiumRequired } from "./license.js";
+import { format, predictions, stationList, stationMetadata, tideRange, TidesError, waterLevels } from "./api.js";
 const text = (s) => ({ content: [{ type: "text", text: s }] });
-const textError = (t) => ({ content: [{ type: "text", text: t }], isError: true });
-const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
+const fail = (s) => ({ content: [{ type: "text", text: s }], isError: true });
+function errorMessage(e) {
+    if (e instanceof TidesError || e instanceof Error)
+        return `Error: ${e.message}`;
+    return `Error: ${String(e)}`;
+}
 export function createServer() {
-    const server = new McpServer({ name: "tides-mcp", version: "1.0.0" });
-    server.registerTool("get_tide_predictions", {
-        title: "Get tide predictions",
-        description: "Get NOAA high low or hourly tide predictions for a station and date range.",
-        inputSchema: z.object({ station: z.string().min(3), begin: z.string().describe("YYYY-MM-DD"), end: z.string().describe("YYYY-MM-DD"), interval: z.enum(["hilo", "h"]).default("hilo"), units: z.enum(["english", "metric"]).default("english") }),
-        annotations: READ_ONLY,
-    }, async ({ station, begin, end, interval, units }) => { try {
-        return text(format(await predictions(station, begin, end, interval, units)));
-    }
-    catch (e) {
-        return textError(`Error: ${e instanceof Error ? e.message : String(e)}`);
-    } });
-    server.registerTool("get_water_levels", {
-        title: "Get water levels",
-        description: "Get observed NOAA water levels for a station and short date range.",
-        inputSchema: z.object({ station: z.string().min(3), begin: z.string(), end: z.string(), interval: z.enum(["6", "h"]).default("6"), units: z.enum(["english", "metric"]).default("english") }),
-        annotations: READ_ONLY,
-    }, async ({ station, begin, end, interval, units }) => { try {
-        return text(format(await waterLevels(station, begin, end, interval, units)));
-    }
-    catch (e) {
-        return textError(`Error: ${e instanceof Error ? e.message : String(e)}`);
-    } });
-    server.registerTool("station_metadata", {
-        title: "Station metadata",
-        description: "What a NOAA station is and what it publishes: name, state, position, tide type, local time zone, SHEF and port codes, and which data product families the station carries.",
-        inputSchema: z.object({ station: z.string().min(3).describe("NOAA station id, 7 or 8 digits, e.g. 9414290") }),
-        annotations: READ_ONLY,
-    }, async (args) => {
-        // ---- paywall: station_metadata ----
-        const paywallMessage = await premiumRequired("station_metadata");
-        if (paywallMessage)
-            return { content: [{ type: "text", text: paywallMessage }], isError: true };
-        // ---- paywall: end ----
+    const server = new McpServer({ name: "tides-mcp", version: "1.0.2" });
+    server.tool("get_tide_predictions", "Get NOAA high low or hourly tide predictions for a station and date range.", {
+        station: z.string().min(3).describe("NOAA station id, e.g. 8443970"),
+        begin: z.string().describe("YYYY-MM-DD"),
+        end: z.string().describe("YYYY-MM-DD"),
+        interval: z.enum(["hilo", "h"]).default("hilo"),
+        units: z.enum(["english", "metric"]).default("english")
+    }, async (a) => {
+        try {
+            return text(format(await predictions(a.station, a.begin, a.end, a.interval, a.units)));
+        }
+        catch (e) {
+            return fail(errorMessage(e));
+        }
+    });
+    server.tool("get_water_levels", "Get observed NOAA water levels for a station and short date range.", {
+        station: z.string().min(3).describe("NOAA station id"),
+        begin: z.string().describe("YYYY-MM-DD"),
+        end: z.string().describe("YYYY-MM-DD"),
+        interval: z.enum(["6", "h"]).default("6"),
+        units: z.enum(["english", "metric"]).default("english")
+    }, async (a) => {
+        try {
+            return text(format(await waterLevels(a.station, a.begin, a.end, a.interval, a.units)));
+        }
+        catch (e) {
+            return fail(errorMessage(e));
+        }
+    });
+    server.tool("list_stations", "List NOAA tide prediction stations, optionally by state.", {
+        state: z.string().length(2).optional().describe("Two-letter state code, e.g. NY")
+    }, async (a) => {
         try {
-            return text(await stationMetadata(args));
+            return text(await stationList(a));
         }
         catch (e) {
-            return textError(`Error: ${e instanceof Error ? e.message : String(e)}`);
+            return fail(errorMessage(e));
         }
     });
-    server.registerTool("harmonic_constituents", {
-        title: "Harmonic constituents",
-        description: "The harmonic constants behind a NOAA station's tide: how many constituents are on file, the principal lunar and solar ones with amplitudes and local phases, the form number that classifies the tide as semidiurnal, mixed or diurnal, and the strongest by amplitude.",
-        inputSchema: z.object({ station: z.string().min(3).describe("NOAA station id, e.g. 9414290"), units: z.enum(["english", "metric"]).default("english"), limit: z.number().describe("Constituents to list, 1-30.").optional() }),
-        annotations: READ_ONLY,
-    }, async (args) => {
-        // ---- paywall: harmonic_constituents ----
-        const paywallMessage = await premiumRequired("harmonic_constituents");
-        if (paywallMessage)
-            return { content: [{ type: "text", text: paywallMessage }], isError: true };
-        // ---- paywall: end ----
+    server.tool("station_metadata", "Station details for one NOAA tide gauge.", {
+        station: z.string().min(3).describe("NOAA station id, e.g. 8443970")
+    }, async (a) => {
         try {
-            return text(await harmonicConstituents(args));
+            return text(await stationMetadata(a));
         }
         catch (e) {
-            return textError(`Error: ${e instanceof Error ? e.message : String(e)}`);
+            return fail(errorMessage(e));
         }
     });
-    server.registerTool("tide_statistics", {
-        title: "Tide statistics",
-        description: "What a set of NOAA high and low predictions adds up to: how many of each, mean high and low water, mean range, the highest high, the lowest low and the greatest high to following low with its times.",
-        inputSchema: z.object({ station: z.string().min(3).describe("NOAA station id, e.g. 9414290"), begin: z.string().describe("YYYY-MM-DD"), end: z.string().describe("YYYY-MM-DD"), units: z.enum(["english", "metric"]).default("english") }),
-        annotations: READ_ONLY,
-    }, async (args) => {
+    server.tool("tide_range", "Highest, lowest and total tide range for a date window.", {
+        station: z.string().min(3).describe("NOAA station id"),
+        begin: z.string().describe("YYYY-MM-DD"),
+        end: z.string().describe("YYYY-MM-DD"),
+        units: z.enum(["english", "metric"]).default("english")
+    }, async (a) => {
         try {
-            return text(await tideStatistics(args));
+            return text(await tideRange(a));
         }
         catch (e) {
-            return textError(`Error: ${e instanceof Error ? e.message : String(e)}`);
+            return fail(errorMessage(e));
         }
     });
     return server;
 }
-export { TidesError };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "tides-mcp",
-  "version": "1.0.1",
-  "description": "Use this MCP server to NOAA tides and currents predictions and water levels. Tools include get tide predictions, get water levels",
+  "version": "1.0.3",
+  "description": "MCP server for NOAA tides and currents predictions and water levels.",
   "type": "module",
   "mcpName": "io.github.mrfentmen/tides-mcp",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mrfentmen/tides-mcp.git"
+    "url": "git+https://github.com/mrfentmen/awesome-servers.git"
   },
   "bin": {
     "tides-mcp": "./dist/index.js"
@@ -35,8 +35,5 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "typescript": "^5.6.0"
-  },
-  "engines": {
-    "node": ">=20"
   }
 }

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.mrfentmen/tides-mcp",
-  "description": "Use this MCP server to NOAA tides and currents predictions and water levels. Tools include get...",
+  "description": "MCP server for NOAA tides and currents predictions and water levels.",
   "repository": {
     "url": "https://github.com/mrfentmen/tides-mcp",
     "source": "github"
   },
-  "version": "1.0.0",
+  "version": "1.0.3",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "tides-mcp",
-      "version": "1.0.0",
+      "version": "1.0.3",
       "transport": {
         "type": "stdio"
       }

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>;

package/dist/license.js

@@ -1,79 +0,0 @@
-// 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 = "tides-mcp";
-// Tools that need a key. Everything else is free.
-const PREMIUM = new Set([
-    "station_metadata",
-    "harmonic_constituents",
-]);
-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");
-}