Title: MksDdn Migrate Content Author: Max Published: January 19, 2026 Last modified: April 30, 2026 --- Search plugins ![](https://s.w.org/plugins/geopattern-icon/mksddn-migrate-content.svg) # MksDdn Migrate Content By [Max](https://profiles.wordpress.org/mksddn/) [Download](https://downloads.wordpress.org/plugin/mksddn-migrate-content.2.3.1.zip) * [Details](https://test.wordpress.org/plugins/mksddn-migrate-content/#description) * [Reviews](https://test.wordpress.org/plugins/mksddn-migrate-content/#reviews) * [Installation](https://test.wordpress.org/plugins/mksddn-migrate-content/#installation) * [Development](https://test.wordpress.org/plugins/mksddn-migrate-content/#developers) [Support](https://wordpress.org/support/plugin/mksddn-migrate-content/) ## Description MksDdn Migrate Content is a clean-room migration suite that packages your site into deterministic `.wpbkp` archives. Each bundle contains a manifest, checksum, database segments, media, selected files, and user decisions, so imports stay predictable. #### Why MksDdn Migrate Content? * **Dual export modes** – choose Full Site (database + uploads/plugins/mu-plugins/ themes) or Selected Content (multi-select posts/pages/CPTs) with or without referenced media. * **Chunked pipeline** – large archives stream through REST API endpoints with resume tokens, so multi‑GB transfers survive flaky networks. * **User merge control** – compare archive vs current users and decide how to merge conflicts. * **Theme import mode** – when a theme archive is detected, choose replace vs merge before applying changes. * **Integrity & safety** – `.wpbkp` archives ship with manifests and checksums; imports verify capabilities, nonces, and disk space before touching data. * **Import preflight** – unified import is a two-step flow: run preflight (read- only report), then start the real import from the report without uploading the file again (browser uploads are staged server-side between steps). #### Feature Highlights * Archive format with manifest, checksum, and payload folders (`content.json`, ` media/`, `options/`, filesystem slices). * Media scanner that collects featured images, galleries, attachments referenced inside blocks or shortcodes. * File-system coverage for `wp-content/uploads`, `wp-content/plugins`, `wp-content/ mu-plugins`, `wp-content/themes` with filters to skip VCS/system files. * Chunked upload/download JS client with live progress, auto-resume, and graceful fallback to direct transfer. * Server file import – select backup files directly from `wp-content/uploads/mksddn- mc/imports/` directory without browser uploads. * Custom `.wpbkp` drag-and-drop uploader with checksum guardrails (UI polish deferred to next milestone, functionality already complete). ### Architecture The plugin follows SOLID principles and WordPress Coding Standards with a clean, modular architecture: #### Service Container & Dependency Injection * Centralized `ServiceContainer` manages all dependencies * Service Providers (`CoreServiceProvider`, `AdminServiceProvider`, `ExportServiceProvider`,` ImportServiceProvider`, `ChunkServiceProvider`) register services * All dependencies resolved through container, eliminating direct instantiation * Full support for interface-based dependency injection #### Request Handlers * `ExportRequestHandler` – handles export requests * `ImportRequestHandler` – delegates to specialized import services (supports unified import via `UnifiedImportOrchestrator`) * `UserMergeRequestHandler` – processes user merge operations * `ThemePreviewRequestHandler` – handles theme preview cancel operations * `ChunkRestController` – REST API controller for chunked upload/download operations * All handlers implement corresponding interfaces for testability #### Service Layer * `SelectedContentImportService` – handles selected content imports * `FullSiteImportService` – manages full site imports * `ThemeImportService` – handles theme archive imports * `UnifiedImportOrchestrator` – orchestrates unified import with automatic type detection; step 1 is always preflight, step 2 runs the real import using a stored file reference * `ImportPreflightService` – read-only analysis for unified import preflight * `PreflightReportStore` – short-lived transient storage for preflight reports and follow-up import handles (staged browser uploads under `wp-content/uploads/ mksddn-mc/preflight/`, or chunk/server identifiers) * `ImportTypeDetector` – detects import type (full site or selected content) from archive file * `ImportFileValidator` – validates uploaded files * `ImportPayloadPreparer` – prepares import payloads * `ServerBackupScanner` – scans and validates backup files on the server * `ResponseHandler` – manages redirects and status messages * `NotificationService` – handles user notifications * `ProgressService` – tracks operation progress * `ErrorHandler` – centralized error handling and logging * `UserDiffBuilder` – builds user difference comparison * `UserMergeApplier` – applies user merge operations * `ThemePreviewStore` – stores pending theme import previews * `DeactivationCleanup` – clears temporary upload state and service directories when the plugin is deactivated * `PostImportMaintenance` – centralizes cache/rewrite cleanup after full import and emergency purge if the database was partially updated; performs global flush plus targeted `wp_cache_flush_group()` when supported, bumps posts/terms/comments last_changed hooks, exposes `mksddn_mc_post_import_object_cache_flush_groups` filter, integrates page-cache plugins via best-effort function calls and hooks * `FullImportMaintenance` – file-based runtime lock and early 503 gate while a full-site import is running (admin, CLI, cron exempt; REST blocked unless explicitly allowed) #### Contracts (Interfaces) All key components implement interfaces: * `ExporterInterface`, `ImporterInterface`*` MediaCollectorInterface`, `ChunkJobRepositoryInterface` * `UserPreviewStoreInterface`,` ThemePreviewStoreInterface`, `UserDiffBuilderInterface`, `UserMergeApplierInterface`*` NotificationServiceInterface`, `ProgressServiceInterface` * `ArchiveHandlerInterface`,` ValidatorInterface` * Request handler interfaces for all handlers #### Error Handling * Specialized exceptions: `ValidationException`, `FileOperationException`, `DatabaseOperationException`,` ImportException`, `ExportException` * Centralized `ErrorHandler` for consistent error processing * Proper logging and user-friendly error messages * Validation classes: `ArchiveValidator`, `ImportDataValidator`, `ExportDataValidator`,` FileValidator` #### Performance * `BatchLoader` for optimized database queries (prevents N+1 problems) * Efficient media collection with batch processing (`AttachmentCollector`) * Chunked transfer for large files via REST API (`ChunkRestController`) * Memory-efficient streaming for large archives * `FullArchivePayload` for efficient archive payload handling * `ContentCollector` for filesystem content collection #### Security * All admin operations check `current_user_can('manage_options')` * Nonce verification for all forms and AJAX requests * REST API endpoints protected with permission callbacks * Input sanitization using WordPress sanitization functions * Output escaping with `esc_html()`, `esc_attr()`, `esc_url()` * File upload validation with MIME type checking * Path traversal protection for server file access (`ServerBackupScanner`) * Path traversal protection for archive extraction (full site + theme import) * `SiteUrlGuard` prevents accidental site URL changes during import * `ImportLock` prevents concurrent import operations * `DomainReplacer` safely handles URL replacement during migrations ## Installation 1. Upload the `mksddn-migrate-content` folder to the `/wp-content/plugins/` directory, or install via the Plugins page in WordPress. 2. Activate the plugin through the ‘Plugins’ menu in WordPress. 3. Go to Tools Migrate Content to run exports and imports. ## FAQ ### What is inside a `.wpbkp` archive? Each archive stores a manifest (checksums, metadata, timestamps), JSON payloads for selected entities, optional filesystem slices (uploads/plugins/themes), media binaries, and user-merge selections. Imports verify the manifest before processing. ### How is `.wpbkp` different from `.json` exports? .json exports are lightweight (content only) and convenient for quick edits. `.wpbkp` adds media, filesystem slices, and checksums. Use `.wpbkp` for full fidelity. ### Does it support ACF and custom post types? Yes. Any public post type plus Advanced Custom Fields metadata is exported/imported. Taxonomies, menus, widgets, and serialized options are also covered. ### How do chunked uploads resume? The JS client splits files into 5–10 MB chunks (auto-tuned by server limits). Each chunk is hashed and acknowledged via REST API endpoints (`mksddn/v1/chunk/*`). If the browser reloads, the resume token restarts from the last confirmed chunk. ### How do I import a backup file from the server? You can import backup files directly from the server without uploading them through the browser. Place your `.wpbkp` or `.json` archive files in the `wp-content/uploads/ mksddn-mc/imports/` directory (the plugin will create this directory automatically if it doesn’t exist). Then, in the import form, toggle the “Select from server” option instead of “Upload file”. The plugin will scan the imports directory and display available files with their size and modification date. Select the desired file and proceed with the import. This method is especially useful for large files or when you have direct server access via FTP/SFTP. ### What is cleaned up when the plugin is deactivated? Chunk upload state under `wp-content/uploads/mksddn-mc/jobs/`, theme replace backups under `wp-content/mksddn-mc/theme-backups/`, the import lock transient, the full- site import maintenance lock file, server-backup list cache, user/theme preview transients, optional `mksddn_mc_storage_path`, and theme preview index data. Files in `wp-content/uploads/mksddn-mc/imports/` are not removed by default; set the ` mksddn_mc_deactivation_clear_imports` filter to true if you want that directory emptied on deactivation. ### How are caches and maintenance mode handled during import? Full-site import calls `wp_cache_flush()`, then clears core query-related object- cache groups (`posts`, `post-queries`, and related groups) via `wp_cache_flush_group()` when the drop-in reports support (`wp_cache_supports('flush_group')`; WordPress 6.1+). It also bumps posts/terms/comments `last_changed` where available and deletes cached `alloptions` / `notoptions` keys—this reduces stale cached post lists after raw `TRUNCATE`/`INSERT` restores when a persistent Redis/Memcached drop-in behaves imperfectly on global flush. Use the `mksddn_mc_post_import_object_cache_flush_groups` filter (see `Support\PostImportMaintenance`) if your hosting uses extra cache groups or multisite/global keys. Rewrite rule runtime state is cleared, then common page/ HTML cache plugins are purged best-effort (WP Rocket, LiteSpeed via hook, W3 Total Cache, WP Super Cache, Autoptimize). Edge CDN or host HTML caches are not purged automatically: hook `mksddn_mc_post_import_cache_purge` (and related actions in code) to integrate your stack. While a full-site import holds the import lock, public front-end and REST requests may receive HTTP 503. The plugin writes both a runtime lock outside the database and WordPress core `.maintenance` file, so parallel requests are blocked even if `wp_options` is being replaced. WP-CLI, cron, and logged-in administrators with `manage_options` are not blocked by the plugin-level gate. If the PHP process fatals after the database was partially written, an emergency cache purge runs on shutdown when possible. Selected content import avoids a global flush and only runs `clean_post_cache()` on posts that were imported or updated, then fires `mksddn_mc_selected_import_completed` with their IDs. ### How can I verify object cache handling after a full-site import? On a staging copy with `WP_DEBUG` and `WP_DEBUG_LOG` enabled, run a full-site import and confirm the log does not show repeated `MksDdn Migrate [object cache]: wp_cache_flush_group(` failures. Then open admin list tables for custom post types (e.g. form submissions) and front-end forms: rows should load without PHP errors, and new submissions should save normally. On production with Redis/Memcached, you can also compare behaviour before/after a manual object-cache flush from your cache plugin—if symptoms only clear after manual flush, use the filter above or contact the host about drop-in flush support. ### Can I merge users without overwriting existing accounts? Yes. The user merge dialog shows archive/current rows with conflict indicators. You can keep current roles, replace metadata, or skip entire accounts. ### Does it touch production files directly? Filesystem operations run through `WP_Filesystem`, honor capability checks, and avoid `.git`, `.svn`, and OS temp files. Full-site imports back up theme directories before replace and restore them if extraction fails. ### How does unified import preflight work? Step 1 runs file detection and read-only analysis (payload parsing, user diff scan for full-site archives, theme list scan) and stores a short-lived report on the Import page. Step 2 starts the real import using the same file (no second upload for browser uploads; chunked and server picks are referenced from the preflight session). Preflight does not acquire the import lock or apply database changes. It is a best-effort preview (v1): validate on a staging site when possible. ## Reviews There are no reviews for this plugin. ## Contributors & Developers “MksDdn Migrate Content” is open source software. The following people have contributed to this plugin. Contributors * [ Max ](https://profiles.wordpress.org/mksddn/) [Translate “MksDdn Migrate Content” into your language.](https://translate.wordpress.org/projects/wp-plugins/mksddn-migrate-content) ### Interested in development? [Browse the code](https://plugins.trac.wordpress.org/browser/mksddn-migrate-content/), check out the [SVN repository](https://plugins.svn.wordpress.org/mksddn-migrate-content/), or subscribe to the [development log](https://plugins.trac.wordpress.org/log/mksddn-migrate-content/) by [RSS](https://plugins.trac.wordpress.org/log/mksddn-migrate-content/?limit=100&mode=stop_on_copy&format=rss). ## Changelog #### 2.3.1 * Fixed: Selected content import now preserves registered custom post types instead of falling back to pages. #### 2.3.0 * Enhanced: Export flow now has stricter payload checks, clearer validation errors, and safer type handling to make large exports more predictable. * Added: Full-site import maintenance now applies a stronger runtime lock/503 gate and expanded post-import cache cleanup hooks for common cache stacks. * Improved: Export file-system checks now validate directory writability more reliably before writing artifacts. #### 2.2.1 * Fixed: Admin redirects after import — `NotificationService::safe_redirect_exit()` validates URLs like `wp_safe_redirect()` but skips the `wp_redirect` filter to avoid Query Monitor fatals when its hook collector runs during redirects after a full database import. #### 2.2.0 * Added: Unified import preflight — mandatory first step with read-only analysis and inline report (`ImportPreflightService`, `PreflightReportStore`); second step runs import without re-uploading (staged copy for browser uploads). #### 2.1.9 * Fixed: Selected content import — ACF nested groups: removed post-import deletion of bare subfield meta keys (could break groups such as `info_cards`); meta fallback no longer restores an empty root `{$field}` row when nested `{$field}_*` keys exist in the export payload. #### 2.1.8 * Fixed: Bundle import — Polylang translation groups from `taxonomies.post_translations`( remap + `pll_save_post_translations()`); skip assigning `post_translations` terms on import. * Fixed: Selected content import — ACF: field keys, `pll_set_post_language` before save, scoped `meta` fallback when `update_field` leaves empty values, cleanup of stray group subfield meta. #### 2.1.7 * Added: On plugin deactivation, `DeactivationCleanup` removes chunk job files, theme import backups under `wp-content/mksddn-mc/theme-backups/`, import lock and related transients, and clears theme preview data; optional filter `mksddn_mc_deactivation_clear_imports` may empty the server imports directory; action `mksddn_mc_deactivation_cleanup` runs after the default steps. * Fixed: Selected content import — Polylang translation links when the bundle includes every post in a group (`_pll_translations` remapped, `pll_save_post_translations()`). #### 2.1.6 * Rollback: Codebase restored to the 2.1.4 state; supersedes 2.1.5. #### 2.1.5 * Enhanced: Full-site export — time-sliced runner, incremental database reads, resumable chunked download, clearer errors for missing/unreadable files. * Changed: Export step time budget in settings; removed deprecated helpers. #### 2.1.4 * Fixed: User merge replace mode — `resolve_remote_user_login()` uses loose `sanitize_user()` first; `force_wp_users_login_and_password()` updates `wp_users` after `wp_update_user()` so archive login and password hash stay paired (avoids old username + new password). #### 2.1.3 * Added: Export memory management (`ExportMemoryHelper`) with configurable min/ max export memory limits in `PluginConfig` for more stable full-site exports. * Enhanced: Full site export/import now includes `wp-content/mu-plugins` alongside uploads, plugins, and themes. * Fixed: User merge — when updating existing users, login is adjusted to stay unique if the archive login collides with another account. #### 2.1.2 * Fixed: UnifiedImportOrchestrator constructor now receives ThemePreviewStoreInterface as 5th argument (fixes full-site import error when wrong service was passed). * Enhanced: AdminServiceProvider – explicit use of ThemePreviewStoreInterface for UnifiedImportOrchestrator and related registrations. #### 2.1.1 * Added: Theme import preview – preview theme changes before applying. * Added: Russian translation (ru_RU). * Enhanced: Theme import – full theme replacement, improved error handling and validation. * Enhanced: ChunkJobRepository – improved directory handling and cleanup for chunked transfers. * Enhanced: FullSiteImportService – WooCommerce maintenance and plugin reactivation after import. * Enhanced: Theme export section descriptions for clarity. #### 2.1.0 * Added: Theme export and import functionality – users can now export and import WordPress themes with merge and replace mode options. * Enhanced: Export and Import Handlers for improved data handling – added local dates, modified dates, menu order, comment status, and parent page slug to exports. Import now sorts items by parent-child relationships. * Enhanced: Taxonomy handling in Export and Import Handlers – preloads taxonomy terms for all post types including Polylang language taxonomy, improving export accuracy and import consistency. * Enhanced: DomainReplacer for improved URL normalization – prevents port duplication in URLs during domain replacements. * Enhanced: Import locking mechanism with improved error handling and automatic lock release on fatal errors, ensuring only one import can run at a time. * Enhanced: Admin styles with new flexbox layout classes for better organization and responsiveness of selection elements. * Enhanced: Theme import and export with improved logging, optimized theme retrieval, and validation to prevent deletion of active or parent themes. * Refactored: Removed deprecated import templates and sections from admin interface for cleaner codebase. #### 2.0.3 * Fixed: Media files are now properly linked to pages/posts during wpbkp import. ACF Image fields correctly receive new attachment IDs for all return formats. #### 2.0.2 * Fixed: Partial export material selection now displays items from all languages when Polylang is installed. #### 2.0.1 * Enhanced: FullDatabaseImporter type safety with integer casting for batch offsets. * Enhanced: UserMergeApplier recursive validation for incomplete objects in user meta, preventing import errors. #### 2.0.0 * Added: Unified import feature with automatic type detection – single import form automatically detects and routes full site or selected content imports. * Added: Import locking mechanism to prevent concurrent import operations and ensure data integrity. * Added: AJAX search functionality for post selection, improving usability when selecting content for export. * Enhanced: Download progress handling in chunked transfers for better user experience. * Enhanced: Security with improved nonce verification in unified import orchestrator. * Refactored: Import handling architecture with unified orchestrator for cleaner code organization. #### 1.4.0 * Added: Post-import maintenance tasks (cache flushing, WooCommerce maintenance, plugin reactivation hooks). * Enhanced: SQL safety with improved sanitization and escaping for database operations. * Enhanced: Memory management with adaptive strategies to prevent exhaustion during large imports. * Enhanced: Error handling and logging throughout import processes. * Added: RedirectTrait for streamlined HTTP redirect handling during background imports. * Refactored: Database row insertion logic for improved performance. #### 1.3.2 * Enhanced: Improved memory management in FullArchivePayload – original memory limit is now stored and restored during JSON decoding for large files, ensuring efficient resource handling. * Enhanced: Enhanced domain signature collection in DomainReplacer to include port and scheme information, improving URL replacement accuracy during migrations. #### 1.3.1 * Fixed: Improved compliance with WordPress.org plugin guidelines – all scripts/ styles now properly enqueued, conditional loading for admin files, removed inline code. * Enhanced: Real-time import progress tracking via REST API polling without page refresh. * Enhanced: Improved background import execution with fastcgi_finish_request() support for uninterrupted processing. #### 1.3.0 * Added MKSDDN_MC_BASENAME constant for plugin path management. * Introduced dedicated CSS file for import progress styling. * Added user warnings to prevent accidental lockouts when deselecting all users. * Enhanced user selection handling to preserve current admin user during imports. * Improved data sanitization across handlers. * Added import completion notices in NotificationService. * Implemented backup and restore of critical options during full database imports. * Enhanced file verification in FullContentImporter. * Refactored FilesystemHelper to initialize permissions dynamically. * Enhanced ImportProgressPage with static CSS/JS generation methods. #### 1.2.5 * Refactored BatchLoader to enhance database query efficiency by replacing placeholder- based queries with sanitized ID strings, improving security and performance. * Implemented dedicated admin styles and scripts with separate CSS and JavaScript files for better code organization and maintainability. * Added CSS for progress bars, sections, grids, and cards to enhance the admin interface. * Introduced JavaScript for progress bar functionality with dynamic updates during content migration. * Refactored code to remove deprecated inline styles and scripts, promoting better separation of concerns. * Updated comments for clarity on caching and sanitization practices. * Added PHPCS ignore comments for specific cases to address coding standards compliance. #### 1.2.4 * Enhanced ACF field export and import support for groups and repeaters. * Improved ACF field handling in BatchLoader by using get_fields() directly for better efficiency. * Enhanced link field processing in repeaters and groups during import operations. * Refactored ACF field retrieval in WpFunctionsWrapper to ensure consistent array return types. * Improved data integrity during ACF imports with better field value handling and recursive media remapping. #### 1.2.3 * Enhanced FilesystemHelper with dynamic definition of FS_CHMOD_FILE and FS_CHMOD_DIR based on existing WordPress file permissions, improving filesystem operations compatibility. * Added ensure_directory() method to FilesystemHelper for consistent directory creation with proper error handling. * Refactored directory creation logic in ChunkJobRepository, ChunkRestController, and FullContentExporter to utilize FilesystemHelper for improved error handling and consistency. * Improved file permissions handling in put_stream() method to ensure proper chmod after streaming operations. #### 1.2.2 #### 1.2.1 * Updated PHPCS ignore comments for set_time_limit and ini_set to current standards. #### 1.2.0 * Added real-time progress tracking for import operations with visual progress bar. * Implemented incremental database import to optimize memory usage for large backups. * Enhanced memory and time limit management based on file size to prevent failures. * Added output flushing for better responsiveness during import. * Improved error handling and logging for large file imports. * Removed unused auto-increment key handling code for cleaner codebase. #### 1.1.0 * Added server file import feature – users can now select backup files directly from the server imports directory. * Introduced ServerBackupScanner service for scanning and validating backup files on the server. * Added JavaScript module (server-file-selector.js) for dynamic file selection with AJAX loading. * Updated import forms (full site and selected content) with source toggle (upload vs server). * Enhanced FullSiteImportService and SelectedContentImportService to support server file imports. * Added AJAX endpoint (mksddn_mc_get_server_backups) for retrieving available backup files. * Implemented file caching via WordPress transients to improve performance. * Added path traversal protection for secure server file access. * Server file selector displays file size and modification date for better user experience. #### 1.0.1 * Fixed duplicate PRIMARY KEY errors during full site import (wp_postmeta, wp_actionscheduler_actions). * Auto-increment PRIMARY KEY fields are now excluded from inserts to let database generate new values. * Added INSERT IGNORE fallback for handling duplicate key conflicts during import. #### 1.0.0 * Clean-room `.wpbkp` archive format with manifest + checksum validator. * Full-site export/import (database + uploads/plugins/themes) with streaming chunked transfer. * Selected content export with multi-select CPT picker, media toggle, and JSON fallback. * Media collector/restorer for featured images, galleries, and inline attachments. * Chunked upload/download pipeline with resume tokens, progress UI, and safe fallbacks. * User merge matrix covering new, conflicting, and existing accounts with role/ metasync choices. * Refactored architecture following SOLID principles with Service Container and Dependency Injection. * All components use interfaces (Contracts) for improved testability and maintainability. * Separated concerns: Request Handlers, Services, and Views are clearly divided. * Specialized exception handling for better error management. * Optimized database queries using BatchLoader to prevent N+1 problems. ## Meta * Version **2.3.1** * Last updated **2 weeks ago** * Active installations **Fewer than 10** * WordPress version ** 6.2 or higher ** * Tested up to **6.9.4** * PHP version ** 8.0 or higher ** * Language * [English (US)](https://wordpress.org/plugins/mksddn-migrate-content/) * Tags * [backup](https://test.wordpress.org/plugins/tags/backup/)[export](https://test.wordpress.org/plugins/tags/export/) [import](https://test.wordpress.org/plugins/tags/import/)[migration](https://test.wordpress.org/plugins/tags/migration/) * [Advanced View](https://test.wordpress.org/plugins/mksddn-migrate-content/advanced/) ## Ratings No reviews have been submitted yet. [Your review](https://wordpress.org/support/plugin/mksddn-migrate-content/reviews/#new-post) [See all reviews](https://wordpress.org/support/plugin/mksddn-migrate-content/reviews/) ## Contributors * [ Max ](https://profiles.wordpress.org/mksddn/) ## Support Got something to say? Need help? [View support forum](https://wordpress.org/support/plugin/mksddn-migrate-content/)