claude-plugin-wordpress-manager 1.8.0 → 1.9.0

package/servers/wp-rest-bridge/build/tools/multisite-sites.d.ts

@@ -0,0 +1,150 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const msListSitesSchema: z.ZodObject<{
+    site_id: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    site_id?: string | undefined;
+}, {
+    site_id?: string | undefined;
+}>;
+declare const msGetSiteSchema: z.ZodObject<{
+    blog_id: z.ZodNumber;
+    site_id: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    blog_id: number;
+    site_id?: string | undefined;
+}, {
+    blog_id: number;
+    site_id?: string | undefined;
+}>;
+declare const msCreateSiteSchema: z.ZodObject<{
+    slug: z.ZodString;
+    title: z.ZodString;
+    email: z.ZodString;
+    site_id: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    slug: string;
+    title: string;
+    email: string;
+    site_id?: string | undefined;
+}, {
+    slug: string;
+    title: string;
+    email: string;
+    site_id?: string | undefined;
+}>;
+declare const msActivateSiteSchema: z.ZodObject<{
+    blog_id: z.ZodNumber;
+    active: z.ZodBoolean;
+    site_id: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    active: boolean;
+    blog_id: number;
+    site_id?: string | undefined;
+}, {
+    active: boolean;
+    blog_id: number;
+    site_id?: string | undefined;
+}>;
+declare const msDeleteSiteSchema: z.ZodObject<{
+    blog_id: z.ZodNumber;
+    confirm: z.ZodLiteral<true>;
+    site_id: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    blog_id: number;
+    confirm: true;
+    site_id?: string | undefined;
+}, {
+    blog_id: number;
+    confirm: true;
+    site_id?: string | undefined;
+}>;
+export declare const multisiteSiteTools: Tool[];
+export declare const multisiteSiteHandlers: {
+    ms_list_sites: (params: z.infer<typeof msListSitesSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    ms_get_site: (params: z.infer<typeof msGetSiteSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    ms_create_site: (params: z.infer<typeof msCreateSiteSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    ms_activate_site: (params: z.infer<typeof msActivateSiteSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    ms_delete_site: (params: z.infer<typeof msDeleteSiteSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+};
+export {};

package/servers/wp-rest-bridge/build/tools/multisite-sites.js

@@ -0,0 +1,160 @@
+import { executeWpCli, isMultisite } from '../wpcli.js';
+import { z } from 'zod';
+// ── Schemas ──────────────────────────────────────────────────────────
+const msListSitesSchema = z.object({
+    site_id: z.string().optional().describe('Target site ID (defaults to active site)')
+}).strict();
+const msGetSiteSchema = z.object({
+    blog_id: z.number().describe('Blog ID of the sub-site to retrieve'),
+    site_id: z.string().optional().describe('Target site ID (defaults to active site)')
+}).strict();
+const msCreateSiteSchema = z.object({
+    slug: z.string().describe('URL slug for the new sub-site (e.g., "blog", "shop")'),
+    title: z.string().describe('Title of the new sub-site'),
+    email: z.string().describe('Admin email for the new sub-site'),
+    site_id: z.string().optional().describe('Target site ID (defaults to active site)')
+}).strict();
+const msActivateSiteSchema = z.object({
+    blog_id: z.number().describe('Blog ID of the sub-site'),
+    active: z.boolean().describe('true to activate, false to deactivate'),
+    site_id: z.string().optional().describe('Target site ID (defaults to active site)')
+}).strict();
+const msDeleteSiteSchema = z.object({
+    blog_id: z.number().describe('Blog ID of the sub-site to delete'),
+    confirm: z.literal(true).describe('Must be true to confirm deletion (safety gate)'),
+    site_id: z.string().optional().describe('Target site ID (defaults to active site)')
+}).strict();
+// ── Tools ────────────────────────────────────────────────────────────
+export const multisiteSiteTools = [
+    {
+        name: 'ms_list_sites',
+        description: 'Lists all sub-sites in a WordPress Multisite network. Requires wp-cli and is_multisite configuration.',
+        inputSchema: { type: 'object', properties: msListSitesSchema.shape }
+    },
+    {
+        name: 'ms_get_site',
+        description: 'Gets details of a specific sub-site by blog ID.',
+        inputSchema: { type: 'object', properties: msGetSiteSchema.shape }
+    },
+    {
+        name: 'ms_create_site',
+        description: 'Creates a new sub-site in the multisite network.',
+        inputSchema: { type: 'object', properties: msCreateSiteSchema.shape }
+    },
+    {
+        name: 'ms_activate_site',
+        description: 'Activates or deactivates a sub-site in the multisite network.',
+        inputSchema: { type: 'object', properties: msActivateSiteSchema.shape }
+    },
+    {
+        name: 'ms_delete_site',
+        description: 'Permanently deletes a sub-site. Requires confirm: true as safety gate.',
+        inputSchema: { type: 'object', properties: msDeleteSiteSchema.shape }
+    }
+];
+// ── Helpers ──────────────────────────────────────────────────────────
+function requireMultisite(siteId) {
+    if (!isMultisite(siteId)) {
+        throw new Error(`Site is not configured as multisite. ` +
+            `Set is_multisite: true in WP_SITES_CONFIG.`);
+    }
+}
+// ── Handlers ─────────────────────────────────────────────────────────
+export const multisiteSiteHandlers = {
+    ms_list_sites: async (params) => {
+        try {
+            requireMultisite(params.site_id);
+            const result = await executeWpCli('site list', params.site_id);
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: result }]
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error listing sites: ${error.message}` }]
+                }
+            };
+        }
+    },
+    ms_get_site: async (params) => {
+        try {
+            requireMultisite(params.site_id);
+            const result = await executeWpCli(`site list --blog_id=${params.blog_id}`, params.site_id);
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: result }]
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error getting site: ${error.message}` }]
+                }
+            };
+        }
+    },
+    ms_create_site: async (params) => {
+        try {
+            requireMultisite(params.site_id);
+            const result = await executeWpCli(`site create --slug=${params.slug} --title="${params.title}" --email=${params.email}`, params.site_id, { skipJson: true });
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: result }]
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error creating site: ${error.message}` }]
+                }
+            };
+        }
+    },
+    ms_activate_site: async (params) => {
+        try {
+            requireMultisite(params.site_id);
+            const action = params.active ? 'activate' : 'deactivate';
+            const result = await executeWpCli(`site ${action} ${params.blog_id}`, params.site_id, { skipJson: true });
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: result || `Site ${params.blog_id} ${action}d successfully.` }]
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error ${params.active ? 'activating' : 'deactivating'} site: ${error.message}` }]
+                }
+            };
+        }
+    },
+    ms_delete_site: async (params) => {
+        try {
+            requireMultisite(params.site_id);
+            const result = await executeWpCli(`site delete ${params.blog_id} --yes`, params.site_id, { skipJson: true });
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: result || `Site ${params.blog_id} deleted successfully.` }]
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error deleting site: ${error.message}` }]
+                }
+            };
+        }
+    }
+};

package/servers/wp-rest-bridge/build/types.d.ts

@@ -233,4 +233,17 @@ export interface WCCoupon {
     minimum_amount: string;
     maximum_amount: string;
 }
+export interface WPNetworkSite {
+    blog_id: number;
+    url: string;
+    domain: string;
+    path: string;
+    registered: string;
+    last_updated: string;
+    public: boolean;
+    archived: boolean;
+    mature: boolean;
+    spam: boolean;
+    deleted: boolean;
+}
 export {};

package/servers/wp-rest-bridge/build/wordpress.d.ts

@@ -1,3 +1,17 @@
+interface SiteConfig {
+    id: string;
+    url: string;
+    username: string;
+    password: string;
+    wc_consumer_key?: string;
+    wc_consumer_secret?: string;
+    wp_path?: string;
+    ssh_host?: string;
+    ssh_user?: string;
+    ssh_key?: string;
+    ssh_port?: number;
+    is_multisite?: boolean;
+}
 /**
  * Parse WP_SITES_CONFIG JSON and initialize all site clients
  */
@@ -14,6 +28,10 @@ export declare function listSites(): string[];
  * Get the active site ID
  */
 export declare function getActiveSite(): string;
+/**
+ * Get the SiteConfig for a given site (needed by wpcli module).
+ */
+export declare function getSiteConfig(siteId?: string): SiteConfig | undefined;
 /**
  * Log to stderr (safe for MCP stdio transport)
  */
@@ -55,3 +73,4 @@ export declare function makeWooCommerceRequest(method: string, endpoint: string,
  * Search the WordPress.org Plugin Repository
  */
 export declare function searchWordPressPluginRepository(searchQuery: string, page?: number, perPage?: number): Promise<any>;
+export {};

package/servers/wp-rest-bridge/build/wordpress.js

@@ -33,6 +33,7 @@ const siteClients = new Map();
 const siteLimiters = new Map();
 const wcSiteClients = new Map();
 let activeSiteId = '';
+const parsedSiteConfigs = new Map();
 const MAX_CONCURRENT_PER_SITE = 5;
 const DEFAULT_TIMEOUT_MS = parseInt(process.env.WP_REQUEST_TIMEOUT_MS || '30000', 10);
 const MAX_RETRIES = 3;
@@ -58,6 +59,7 @@ export async function initWordPress() {
         const siteId = 'default';
         await initSiteClient(siteId, url, username || '', password || '');
         activeSiteId = siteId;
+        parsedSiteConfigs.set(siteId, { id: siteId, url, username: username || '', password: password || '' });
         logToStderr(`Initialized single site: ${url}`);
         return;
     }
@@ -73,6 +75,7 @@ export async function initWordPress() {
     }
     for (const site of sites) {
         await initSiteClient(site.id, site.url, site.username, site.password);
+        parsedSiteConfigs.set(site.id, site);
         logToStderr(`Initialized site: ${site.id} (${site.url})`);
     }
     // Initialize WooCommerce clients for sites with WC credentials
@@ -194,6 +197,13 @@ export function listSites() {
 export function getActiveSite() {
     return activeSiteId;
 }
+/**
+ * Get the SiteConfig for a given site (needed by wpcli module).
+ */
+export function getSiteConfig(siteId) {
+    const id = siteId || activeSiteId;
+    return parsedSiteConfigs.get(id);
+}
 // ── Logging ──────────────────────────────────────────────────────────
 /**
  * Log to stderr (safe for MCP stdio transport)

package/servers/wp-rest-bridge/build/wpcli.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Check if a site has WP-CLI access configured (wp_path and optionally ssh_host).
+ */
+export declare function hasWpCli(siteId?: string): boolean;
+/**
+ * Check if a site is configured as multisite.
+ */
+export declare function isMultisite(siteId?: string): boolean;
+/**
+ * Execute a WP-CLI command for a given site.
+ *
+ * - If ssh_host is set: runs via SSH
+ * - If only wp_path is set: runs locally
+ * - Appends --format=json by default for structured output
+ *
+ * @param command WP-CLI command without the leading "wp " (e.g., "site list", "plugin activate hello --network")
+ * @param siteId Site ID (defaults to active site)
+ * @param options.skipJson Don't append --format=json (for commands that don't support it)
+ * @returns stdout as string
+ */
+export declare function executeWpCli(command: string, siteId?: string, options?: {
+    skipJson?: boolean;
+}): Promise<string>;

package/servers/wp-rest-bridge/build/wpcli.js

@@ -0,0 +1,72 @@
+// src/wpcli.ts - WP-CLI execution module (local + SSH)
+import { exec } from 'node:child_process';
+import { getSiteConfig, getActiveSite, logToStderr } from './wordpress.js';
+const WPCLI_TIMEOUT_MS = 30000;
+/**
+ * Check if a site has WP-CLI access configured (wp_path and optionally ssh_host).
+ */
+export function hasWpCli(siteId) {
+    const config = getSiteConfig(siteId || getActiveSite());
+    if (!config)
+        return false;
+    return !!config.wp_path;
+}
+/**
+ * Check if a site is configured as multisite.
+ */
+export function isMultisite(siteId) {
+    const config = getSiteConfig(siteId || getActiveSite());
+    if (!config)
+        return false;
+    return !!config.is_multisite;
+}
+/**
+ * Execute a WP-CLI command for a given site.
+ *
+ * - If ssh_host is set: runs via SSH
+ * - If only wp_path is set: runs locally
+ * - Appends --format=json by default for structured output
+ *
+ * @param command WP-CLI command without the leading "wp " (e.g., "site list", "plugin activate hello --network")
+ * @param siteId Site ID (defaults to active site)
+ * @param options.skipJson Don't append --format=json (for commands that don't support it)
+ * @returns stdout as string
+ */
+export async function executeWpCli(command, siteId, options) {
+    const id = siteId || getActiveSite();
+    const config = getSiteConfig(id);
+    if (!config) {
+        throw new Error(`Site "${id}" not found in configuration.`);
+    }
+    if (!config.wp_path) {
+        throw new Error(`WP-CLI not configured for site "${id}". ` +
+            `Add wp_path to WP_SITES_CONFIG for this site.`);
+    }
+    const formatFlag = options?.skipJson ? '' : ' --format=json';
+    const wpCommand = `wp ${command}${formatFlag}`;
+    let shellCommand;
+    if (config.ssh_host) {
+        // Remote execution via SSH
+        const sshUser = config.ssh_user || 'root';
+        const sshPort = config.ssh_port || 22;
+        const sshKeyFlag = config.ssh_key ? `-i ${config.ssh_key} ` : '';
+        const escapedCommand = `cd ${config.wp_path} && ${wpCommand}`;
+        shellCommand = `ssh ${sshKeyFlag}-p ${sshPort} -o StrictHostKeyChecking=accept-new -o ConnectTimeout=10 ${sshUser}@${config.ssh_host} '${escapedCommand}'`;
+    }
+    else {
+        // Local execution
+        shellCommand = `cd ${config.wp_path} && ${wpCommand}`;
+    }
+    logToStderr(`[${id}] WP-CLI: ${wpCommand}`);
+    return new Promise((resolve, reject) => {
+        exec(shellCommand, { timeout: WPCLI_TIMEOUT_MS }, (error, stdout, stderr) => {
+            if (error) {
+                const msg = stderr?.trim() || error.message;
+                logToStderr(`[${id}] WP-CLI error: ${msg}`);
+                reject(new Error(`WP-CLI error on site "${id}": ${msg}`));
+                return;
+            }
+            resolve(stdout.trim());
+        });
+    });
+}

package/skills/wordpress-router/references/decision-tree.md

@@ -1,4 +1,4 @@
-# Router decision tree (v4 — development + local environment + operations)
+# Router decision tree (v6 — development + local environment + operations + multisite)
 
 This routing guide covers WordPress **development**, **local environment**, and **operations** workflows.
 
@@ -14,7 +14,7 @@ Keywords that indicate **local environment**:
 local site, Studio, LocalWP, Local by Flywheel, wp-env, local WordPress, start site, stop site, create local site, local development, symlink plugin, local database, switch PHP version, localhost, local preview, detect environment, WASM, SQLite local
 
 Keywords that indicate **operations**:
-deploy, push to production, audit, security check, backup, restore, migrate, move site, create post, manage content, site status, check plugins, performance check, SEO audit, WooCommerce, prodotto, ordine, coupon, negozio, catalogo, inventario, vendite, carrello
+deploy, push to production, audit, security check, backup, restore, migrate, move site, create post, manage content, site status, check plugins, performance check, SEO audit, WooCommerce, prodotto, ordine, coupon, negozio, catalogo, inventario, vendite, carrello, multisite, network, sub-site, sub-sito, domain mapping, super admin, network activate
 
 Keywords that indicate **development**:
 create block, block.json, theme.json, register_rest_route, plugin development, hooks, PHPStan, build, test, scaffold, i18n, translation, accessibility, a11y, headless, decoupled, WPGraphQL
@@ -88,6 +88,8 @@ Priority: `gutenberg` > `wp-core` > `wp-site` > `wp-block-theme` > `wp-block-plu
   → `wp-site-manager` agent (Hostinger MCP tools)
 - **WooCommerce / woo / shop / products / orders / coupons / cart / store management / sales report / inventory**
   → `wp-woocommerce` skill + `wp-ecommerce-manager` agent
+- **Multisite / network / sub-sites / domain mapping / super admin / network activate**
+  → `wp-multisite` skill + `wp-site-manager` agent
 
 ## Step 2c: route by local environment intent (keywords)
 

package/skills/wp-multisite/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: wp-multisite
+description: |
+  This skill should be used when the user asks about "multisite", "network admin",
+  "sub-sites", "domain mapping", "super admin", "network activate",
+  "WordPress Multisite network", or any multisite network management operations.
+version: 1.0.0
+---
+
+## Overview
+
+WordPress Multisite network management via WP-CLI (10 MCP tools). Covers sub-site CRUD, network plugin management, Super Admin listing, network settings, and domain mapping guidance. Uses a hybrid approach: REST API where available, WP-CLI for network-only operations.
+
+## When to Use
+
+- User mentions multisite, network, sub-sites, or domain mapping
+- User needs to create, activate, deactivate, or delete sub-sites
+- User wants to network-activate or network-deactivate plugins
+- User needs Super Admin listing or network settings
+- User asks about migrating single-site to multisite or vice versa
+
+## Prerequisites
+
+WP-CLI access and multisite flag must be configured in `WP_SITES_CONFIG`:
+
+```json
+{
+  "id": "mynetwork",
+  "url": "https://network.example.com",
+  "username": "superadmin",
+  "password": "xxxx xxxx xxxx xxxx",
+  "wp_path": "/var/www/wordpress",
+  "ssh_host": "network.example.com",
+  "ssh_user": "deploy",
+  "ssh_key": "~/.ssh/id_rsa",
+  "is_multisite": true
+}
+```
+
+- `wp_path` — required for all wp-cli operations
+- `ssh_host` / `ssh_user` — required for remote sites (omit for local)
+- `is_multisite: true` — required flag to enable ms_* tools
+
+## Detection
+
+Run the detection script to check multisite presence:
+
+```bash
+node skills/wp-multisite/scripts/multisite_inspect.mjs
+```
+
+## Multisite Operations Decision Tree
+
+1. **Sub-site management?**
+   - List all sub-sites → `ms_list_sites`
+   - Get sub-site details → `ms_get_site`
+   - Create new sub-site → `ms_create_site`
+   - Activate/deactivate → `ms_activate_site`
+   - Delete sub-site → `ms_delete_site`
+
+2. **Network plugin management?**
+   - List all plugins (with network status) → `ms_list_network_plugins`
+   - Network-activate plugin → `ms_network_activate_plugin`
+   - Network-deactivate plugin → `ms_network_deactivate_plugin`
+
+3. **Network administration?**
+   - List Super Admins → `ms_list_super_admins`
+   - Get network settings → `ms_get_network_settings`
+
+4. **Domain mapping / network setup / migration?**
+   - See reference files below (no dedicated MCP tool — use wp-cli via Bash)
+
+## Recommended Agent
+
+For complex multi-step multisite operations, use the `wp-site-manager` agent (which has a dedicated Multisite Network Management section).
+
+## Additional Resources
+
+### Reference Files
+
+- **`references/network-setup.md`** — Sub-directory vs sub-domain, wp-config constants, installation
+- **`references/site-management.md`** — CRUD sub-sites, templates, bulk operations
+- **`references/domain-mapping.md`** — Custom domains, SSL, DNS CNAME, sunrise.php
+- **`references/network-plugins.md`** — Network-activated vs per-site plugins, must-use plugins
+- **`references/user-roles.md`** — Super Admin capabilities, site-level roles
+- **`references/migration-multisite.md`** — Single to multisite and back, database tables
+
+### Related Skills
+
+- `wp-wpcli-and-ops` — WP-CLI command reference and multisite flags
+- `wp-security` — Super Admin capabilities and multisite security
+- `wp-deploy` — Deploy to multisite network

package/skills/wp-multisite/references/domain-mapping.md

@@ -0,0 +1,70 @@
+# Domain Mapping
+
+Domain mapping allows each sub-site in a WordPress Multisite network to use its own custom domain instead of the default sub-directory or sub-domain URL.
+
+## Overview
+
+| Default URL | Mapped Domain |
+|-------------|---------------|
+| `network.com/shopA/` | `shopA.com` |
+| `shopB.network.com` | `shopB.com` |
+
+Since WordPress 4.5+, domain mapping is built into core (no plugin required for basic mapping).
+
+## Setup Procedure
+
+### 1. DNS Configuration
+
+For each custom domain, create a DNS record pointing to the network server:
+
+| Record Type | Name | Value |
+|-------------|------|-------|
+| A | `shopA.com` | `<server-ip>` |
+| CNAME | `www.shopA.com` | `shopA.com` |
+
+### 2. WordPress Configuration
+
+In Network Admin > Sites > Edit Site > Domain:
+- Change the site URL to the custom domain
+
+Or via WP-CLI:
+```bash
+wp site list  # find the blog_id
+wp option update home 'https://shopA.com' --url=network.com/shopA/
+wp option update siteurl 'https://shopA.com' --url=network.com/shopA/
+```
+
+### 3. SSL Certificate
+
+Each mapped domain needs its own SSL certificate:
+- **Let's Encrypt**: Use Certbot with `--domains shopA.com,shopB.com`
+- **Wildcard**: Only covers `*.network.com`, NOT custom domains
+- **Multi-domain SAN cert**: Can cover all mapped domains in one cert
+
+### 4. Web Server Configuration
+
+The web server must accept requests for all mapped domains. In Nginx:
+
+```nginx
+server {
+    server_name shopA.com shopB.com network.com *.network.com;
+    # ... standard WordPress config
+}
+```
+
+## sunrise.php (Advanced)
+
+For complex domain mapping logic, WordPress supports a `sunrise.php` drop-in:
+
+- Location: `wp-content/sunrise.php`
+- Loaded very early in the WordPress bootstrap (before plugins)
+- Must be enabled: `define('SUNRISE', true);` in wp-config.php
+- Used by plugins like "WordPress MU Domain Mapping" (legacy) or "Mercator"
+
+## Tips and Gotchas
+
+- **Cookie domain**: After mapping, update `COOKIE_DOMAIN` if login issues occur.
+- **Mixed content**: Ensure all mapped domains use HTTPS to avoid mixed content warnings.
+- **Caching**: Flush caches after domain mapping changes — both server-side and CDN.
+- **Search Console**: Register each mapped domain separately in Google Search Console.
+- **Reverse proxy**: If using Cloudflare or similar, configure the DNS to point to the origin server's IP, not the CDN.