sitezen-mcp 1.0.0

package/dist/state.js

@@ -0,0 +1,81 @@
+// Persistent state for the SiteZen MCP. Lives at ~/.sitezen/state.json so it
+// survives Claude Desktop restarts and is shared across sessions on the same
+// machine. Cross-platform: works on Windows, macOS, Linux.
+//
+// Contents:
+//   - sites: every WP site the user has connected (url + connection_key + label
+//     + last_used). Created via the connect_site tool. Looked up at conversion
+//     time so the user never has to paste site+key again after the first time.
+//   - license_cache: the validated license response, cached 1 hour so the MCP
+//     stays fast and works briefly offline.
+//
+// The file is created lazily on first write — read returns a default empty
+// shape if the file does not exist. NEVER throws on a missing/corrupted file
+// (corrupted → log + treat as empty so the user can recover by re-connecting).
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const STATE_DIR = path.join(os.homedir(), ".sitezen");
+const STATE_FILE = path.join(STATE_DIR, "state.json");
+function emptyState() {
+    return { sites: [] };
+}
+export function readState() {
+    try {
+        if (!fs.existsSync(STATE_FILE))
+            return emptyState();
+        const raw = fs.readFileSync(STATE_FILE, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.sites))
+            return emptyState();
+        return parsed;
+    }
+    catch {
+        // Corrupted file — start fresh. User can re-connect their site.
+        return emptyState();
+    }
+}
+export function writeState(state) {
+    if (!fs.existsSync(STATE_DIR)) {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+    }
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), "utf8");
+}
+export function canonicalUrl(url) {
+    return url.trim().replace(/\/+$/, "").toLowerCase();
+}
+export function findSite(state, url) {
+    const c = canonicalUrl(url);
+    return state.sites.find((s) => canonicalUrl(s.url) === c);
+}
+export function upsertSite(site) {
+    const state = readState();
+    const existing = findSite(state, site.url);
+    if (existing) {
+        existing.connection_key = site.connection_key;
+        existing.label = site.label ?? existing.label;
+        existing.last_used = site.last_used;
+    }
+    else {
+        state.sites.push(site);
+    }
+    writeState(state);
+}
+export function removeSite(url) {
+    const state = readState();
+    const before = state.sites.length;
+    state.sites = state.sites.filter((s) => canonicalUrl(s.url) !== canonicalUrl(url));
+    const removed = state.sites.length < before;
+    if (removed)
+        writeState(state);
+    return removed;
+}
+export function touchSite(url) {
+    const state = readState();
+    const site = findSite(state, url);
+    if (site) {
+        site.last_used = new Date().toISOString();
+        writeState(state);
+    }
+}
+export const STATE_PATH_FOR_DISPLAY = STATE_FILE;

package/dist/tools-session.js

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import { wpRequest, ok } from "./wp-client.js";
+import { readState, upsertSite, removeSite, findSite, canonicalUrl, STATE_PATH_FOR_DISPLAY } from "./state.js";
+import { validateLicense, planLabel } from "./license.js";
+import { Errors } from "./errors.js";
+function failResult(f) {
+    return { content: [{ type: "text", text: JSON.stringify(f, null, 2) }], isError: true };
+}
+/**
+ * Pings the SiteZen plugin's auth-protected /detect endpoint to verify the
+ * URL + connection key are valid before saving. Returns one of:
+ *   "ok"        — site is reachable and the key works
+ *   "unreachable" — DNS / network / CORS / WP not responding
+ *   "bad_key"   — site responded with 401/403
+ */
+async function probeSite(siteUrl, connectionKey) {
+    try {
+        // Use a lightweight endpoint that requires auth. /detect with empty
+        // markup returns immediately so it's cheap.
+        await wpRequest("/detect", {
+            method: "POST",
+            body: { html: "<div></div>" },
+            siteUrl,
+            connectionKey,
+        });
+        return "ok";
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (/\b40[13]\b/.test(msg))
+            return "bad_key";
+        return "unreachable";
+    }
+}
+export function registerSessionTools(server) {
+    /* ─── list_connected_sites ─────────────────────────────────────────── */
+    server.tool("list_connected_sites", "List every WordPress site the user has connected (persists across Claude Desktop restarts), plus their current license plan and remaining quota. Call this BEFORE asking the user for site URL / connection key — if they have a site saved already and their plan has space, reuse it instead of asking again. Returns: {sites:[{url,label,last_used}], license:{plan,sites_used,sites_allowed,conversions_remaining}, can_add_more_sites}.", {}, async () => {
+        const state = readState();
+        const license = await validateLicense(process.env.SITEZEN_LICENSE_KEY);
+        if (!license)
+            return failResult(Errors.noLicenseKey());
+        const sitesUsed = state.sites.length;
+        const canAddMore = license.sites_allowed < 0 || sitesUsed < license.sites_allowed;
+        return ok({
+            ok: true,
+            sites: state.sites.map((s) => ({
+                url: s.url,
+                label: s.label || s.url,
+                last_used: s.last_used,
+            })),
+            license: {
+                plan: planLabel(license.plan),
+                sites_used: sitesUsed,
+                sites_allowed: license.sites_allowed < 0 ? "unlimited" : license.sites_allowed,
+                conversions_remaining: license.conversions_remaining < 0 ? "unlimited" : license.conversions_remaining,
+                upgrade_url: license.upgrade_url,
+            },
+            can_add_more_sites: canAddMore,
+            state_file: STATE_PATH_FOR_DISPLAY,
+            instruction: state.sites.length === 0
+                ? "No sites connected yet. Ask the user for the site URL and connection key, then call connect_site."
+                : "Show the saved site(s) to the user. Ask which one to use; if they want a new site and can_add_more_sites is false, surface the upgrade_url.",
+        });
+    });
+    /* ─── connect_site ─────────────────────────────────────────────────── */
+    server.tool("connect_site", "Save a new WordPress site connection (URL + connection key). Validates the site is reachable AND the key is correct BEFORE saving. Enforces the plan's site limit — refuses to save if the user is already at their limit. After this succeeds, all conversion tools (create_page, push_section_to_page, etc.) can use the site by URL without the user re-sharing the key. Returns clear errors if the URL is unreachable, the key is invalid, or the plan limit is hit.", {
+        site_url: z.string().url().describe("The WordPress site's URL, e.g. https://example.com. Must be reachable and have the SiteZen plugin installed + activated."),
+        connection_key: z.string().min(8).describe("The site's SiteZen connection key from WordPress → SiteZen → Connection."),
+        label: z.string().optional().describe("Optional friendly name to show in the connected-sites list (e.g. 'Acme staging'). Defaults to the URL."),
+    }, async ({ site_url, connection_key, label }) => {
+        const license = await validateLicense(process.env.SITEZEN_LICENSE_KEY);
+        if (!license)
+            return failResult(Errors.noLicenseKey());
+        const state = readState();
+        const existing = findSite(state, site_url);
+        // Enforce site-count limit when adding a NEW site (re-saving the
+        // same URL just refreshes its key, doesn't consume a slot).
+        if (!existing) {
+            const isUnlimited = license.sites_allowed < 0;
+            if (!isUnlimited && state.sites.length >= license.sites_allowed) {
+                return failResult(Errors.limitReachedSites(planLabel(license.plan), license.sites_allowed, license.upgrade_url));
+            }
+        }
+        // Probe before saving — bad URLs or bad keys never reach state.json.
+        const probe = await probeSite(site_url, connection_key);
+        if (probe === "unreachable")
+            return failResult(Errors.siteUnreachable(site_url));
+        if (probe === "bad_key")
+            return failResult(Errors.invalidConnectionKey(site_url));
+        upsertSite({
+            url: canonicalUrl(site_url),
+            connection_key,
+            label: label || canonicalUrl(site_url),
+            last_used: new Date().toISOString(),
+        });
+        return ok({
+            ok: true,
+            message: existing
+                ? `Refreshed connection key for ${site_url}.`
+                : `Connected ${site_url}. You can now convert directly to this site without sharing the key again.`,
+            site: { url: canonicalUrl(site_url), label: label || canonicalUrl(site_url) },
+        });
+    });
+    /* ─── disconnect_site ──────────────────────────────────────────────── */
+    server.tool("disconnect_site", "Remove a saved WordPress site connection. Frees a slot under the user's plan site-limit. Does NOT touch the WordPress site itself — only deletes the saved URL+key from this machine's state.json. Use when the user wants to swap to a different site under a single-site plan, or no longer uses a site.", {
+        site_url: z.string().url().describe("The URL of the site to disconnect (must match a saved entry)."),
+    }, async ({ site_url }) => {
+        const removed = removeSite(site_url);
+        if (!removed)
+            return failResult(Errors.siteNotFound(site_url));
+        return ok({
+            ok: true,
+            message: `Disconnected ${site_url}. The site itself is untouched — only the saved credentials were removed.`,
+        });
+    });
+    /* ─── get_license_status ──────────────────────────────────────────── */
+    server.tool("get_license_status", "Show the user's current SiteZen plan and quota. Useful before a conversion to confirm there are conversions remaining, or when the user asks 'what plan am I on'. Returns {plan, conversions_remaining, sites_used, sites_allowed, upgrade_url}.", {}, async () => {
+        const license = await validateLicense(process.env.SITEZEN_LICENSE_KEY);
+        if (!license)
+            return failResult(Errors.noLicenseKey());
+        const state = readState();
+        return ok({
+            ok: true,
+            plan: planLabel(license.plan),
+            conversions_remaining: license.conversions_remaining < 0 ? "unlimited" : license.conversions_remaining,
+            sites_used: state.sites.length,
+            sites_allowed: license.sites_allowed < 0 ? "unlimited" : license.sites_allowed,
+            upgrade_url: license.upgrade_url,
+        });
+    });
+}