sitezen-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * SiteZen MCP server entry point.
+ *
+ * Boots the MCP server over stdio (the transport Claude Desktop and most
+ * MCP clients use). All tool definitions live in `tools.ts` — this file
+ * just wires the server up and starts listening.
+ *
+ * Usage (after `npm install` + `npm run build`):
+ *   sitezen-mcp                                  # via the package bin
+ *   node dist/index.js                           # direct
+ *   npx -y @sitezen/mcp                          # one-shot (once published)
+ *
+ * Required env vars (set in Claude Desktop's MCP server config):
+ *   SITEZEN_SITE_URL          e.g. https://yoursite.com
+ *   SITEZEN_CONNECTION_KEY    from WP Admin → SiteZen → Connection
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerAllTools } from "./tools.js";
+async function main() {
+    const server = new McpServer({
+        name: "sitezen-mcp",
+        version: "0.1.0",
+    });
+    registerAllTools(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Stdio transport stays open until the client disconnects. No further
+    // code runs here — Node keeps the process alive on the transport's
+    // open file descriptors.
+}
+main().catch((err) => {
+    // MCP clients read stdout for the protocol — keep error output on stderr.
+    process.stderr.write(`[sitezen-mcp] fatal: ${err instanceof Error ? err.stack || err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/license.js

@@ -0,0 +1,121 @@
+// License validation for the SiteZen MCP.
+//
+// Today: stubbed locally — any non-empty key returns the FREE plan so the
+// product flow is testable end-to-end while the real dashboard is built.
+// Override later by setting env SITEZEN_LICENSE_API_URL to the production
+// validate endpoint — the MCP will POST {license_key, action} and use the
+// real response instead of the stub.
+//
+// Validated responses are cached on disk (state.json -> license_cache) for
+// 1 hour so we don't hit the network on every conversion. Cache is keyed by
+// SHA-256 of the raw key so changing the key in the config invalidates the
+// cache automatically.
+import * as crypto from "node:crypto";
+import { readState, writeState } from "./state.js";
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+const UPGRADE_URL = "https://sitezen.io/pricing";
+function hashKey(key) {
+    return crypto.createHash("sha256").update(key.trim()).digest("hex");
+}
+function cacheIsFresh(cache, key) {
+    if (cache.key_hash !== hashKey(key))
+        return false;
+    const age = Date.now() - new Date(cache.cached_at).getTime();
+    return age < CACHE_TTL_MS;
+}
+async function callValidateEndpoint(key) {
+    const apiUrl = process.env.SITEZEN_LICENSE_API_URL;
+    if (!apiUrl)
+        return null;
+    try {
+        const r = await fetch(apiUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ license_key: key, action: "validate" }),
+        });
+        if (!r.ok)
+            return null;
+        const j = await r.json();
+        if (!j || j.ok !== true)
+            return null;
+        return {
+            ok: true,
+            plan: j.plan,
+            sites_allowed: typeof j.sites_allowed === "number" ? j.sites_allowed : 1,
+            conversions_remaining: typeof j.conversions_remaining === "number" ? j.conversions_remaining : 0,
+            upgrade_url: j.upgrade_url || UPGRADE_URL,
+            cached: false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function stubValidate(key) {
+    // Stub: any non-empty key → FREE plan. Replace by setting
+    // SITEZEN_LICENSE_API_URL in env.
+    return {
+        ok: true,
+        plan: "free",
+        sites_allowed: 1,
+        conversions_remaining: 3,
+        upgrade_url: UPGRADE_URL,
+        cached: false,
+    };
+}
+/**
+ * Validate the user's license key. Returns null if the env var is missing or
+ * the key is empty — caller should surface Errors.noLicenseKey() then.
+ * Always cached for 1 hour.
+ */
+export async function validateLicense(licenseKey) {
+    if (!licenseKey || !licenseKey.trim())
+        return null;
+    const key = licenseKey.trim();
+    // Hit cache first
+    const state = readState();
+    if (state.license_cache && cacheIsFresh(state.license_cache, key)) {
+        return {
+            ok: true,
+            plan: state.license_cache.plan,
+            sites_allowed: state.license_cache.sites_allowed,
+            conversions_remaining: state.license_cache.conversions_remaining,
+            upgrade_url: UPGRADE_URL,
+            cached: true,
+        };
+    }
+    // Fresh validation — real endpoint if configured, else stub
+    const fresh = (await callValidateEndpoint(key)) ?? stubValidate(key);
+    // Persist to cache
+    state.license_cache = {
+        key_hash: hashKey(key),
+        plan: fresh.plan,
+        sites_allowed: fresh.sites_allowed,
+        conversions_remaining: fresh.conversions_remaining,
+        cached_at: new Date().toISOString(),
+    };
+    writeState(state);
+    return fresh;
+}
+/**
+ * Decrement the cached conversion count after a successful conversion.
+ * Unlimited (-1) is a no-op. Falls through silently if no cache exists
+ * (next call to validateLicense rebuilds it).
+ */
+export function decrementConversionsRemaining() {
+    const state = readState();
+    if (!state.license_cache)
+        return;
+    if (state.license_cache.conversions_remaining < 0)
+        return; // unlimited
+    state.license_cache.conversions_remaining = Math.max(0, state.license_cache.conversions_remaining - 1);
+    writeState(state);
+}
+export function planLabel(plan) {
+    switch (plan) {
+        case "free": return "Free";
+        case "solo": return "Solo";
+        case "multi": return "Multi";
+        case "agency": return "Agency";
+    }
+}