@instawp/cli 0.0.1-beta.2 → 0.0.1-beta.21

package/dist/commands/local.js

@@ -1,14 +1,22 @@
 import { spawnSync } from 'node:child_process';
-import { join, resolve } from 'node:path';
-import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { randomBytes } from 'node:crypto';
 import chalk from 'chalk';
 import open from 'open';
+import Database from 'better-sqlite3';
+import { resolveFromModule } from '../lib/paths.js';
+import { bundledBusybox } from '../lib/windows-binaries.js';
 import { getLocalInstances, getLocalInstance, setLocalInstance, removeLocalInstance, } from '../lib/config.js';
 import { getNextPort, createInstanceDir, deleteInstanceDir, startServer, startServerBackground, stopServer as stopServerProcess, isServerRunning, checkPlaygroundConnectivity, ensureAutoLogin, } from '../lib/local-env.js';
 import { requireAuth, getClient } from '../lib/api.js';
 import { resolveSite } from '../lib/site-resolver.js';
 import { ensureSshAccess } from '../lib/ssh-keys.js';
-import { rsyncViaSsh, execViaSshToFile } from '../lib/ssh-connection.js';
+import { syncFiles, execViaSsh, execViaSshToFile, scpUpload } from '../lib/ssh-connection.js';
+import { listLocalFiles } from '../lib/sftp-sync.js';
+import { sanitizeName, defaultInstanceName, pushTargetRef, parseTablePrefix, parseSqlTableNames } from '../lib/local-instance.js';
+import { generateMysqlDump } from '../lib/sqlite-to-mysql.js';
 import { success, error, table, spinner, info, isJsonMode } from '../lib/output.js';
 export function registerLocalCommand(program) {
     const local = program
@@ -54,11 +62,11 @@ export function registerLocalCommand(program) {
                 createdAt: new Date().toISOString(),
             };
             setLocalInstance(instance);
-            success(`Instance "${name}" created`);
-            console.log(`
-${chalk.dim('#')} Starting WordPress ${opts.wp} with PHP ${opts.php}...
-${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
-`);
+            if (!isJsonMode()) {
+                success(`Instance "${name}" created`);
+                console.log(`\n${chalk.dim('#')} Starting WordPress ${opts.wp} with PHP ${opts.php}...`);
+                console.log(`${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}\n`);
+            }
             await launchServer(instance, opts);
         }
         catch (err) {
@@ -176,7 +184,11 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
     local
         .command('push <local-name> [cloud-site]')
         .description('Push local wp-content to an InstaWP cloud site')
+        .option('--include <pattern...>', 'Include patterns (e.g. .git)')
         .option('--exclude <pattern...>', 'Additional exclude patterns')
+        .option('--with-db', 'Also push the local database, OVERWRITING the cloud DB (backs it up first)')
+        .option('--no-backup', 'With --with-db: skip the cloud DB backup before overwrite (DANGEROUS)')
+        .option('--force', 'With --with-db: skip the overwrite confirmation prompt')
         .option('--dry-run', 'Show what would be transferred')
         .action(async (localName, cloudSiteArg, opts) => {
         requireAuth();
@@ -185,19 +197,68 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
             error(`Local instance "${localName}" not found.`);
             process.exit(1);
         }
+        const localWpContent = join(instance.path, 'wp-content') + '/';
+        // Where does this push go? Explicit arg → the site this instance was
+        // cloned from (instance.cloudSiteId) → otherwise create a new site. This
+        // is the fix for "push after clone creates a new site": a cloned instance
+        // remembers its origin and pushes back to it.
+        const targetRef = pushTargetRef(cloudSiteArg, instance);
+        // A dry run must be side-effect free. With no target at all (no arg, not a
+        // cloned instance), a real push would *create* a site — which a dry run
+        // must never do — so preview the local files that would be pushed (pure
+        // filesystem walk, no network) and stop. Previously this provisioned a
+        // real site, then failed connecting to its not-yet-resolvable hostname.
+        if (opts.dryRun && !targetRef) {
+            const excludes = ['database', 'db.php', 'mu-plugins', '.git', 'node_modules', '.DS_Store', ...(opts.exclude ?? [])];
+            const files = listLocalFiles(join(instance.path, 'wp-content'), excludes);
+            if (isJsonMode()) {
+                console.log(JSON.stringify({ success: true, dry_run: true, would_create_site: localName, files }));
+            }
+            else {
+                info(`(dry run) Would create cloud site "${localName}" and push ${chalk.dim(localWpContent)}`);
+                for (const rel of files)
+                    console.log(`  ${chalk.dim('↑')} ${rel}`);
+                info(`(dry run) ${files.length} file(s) would be pushed. No cloud site was created.`);
+            }
+            return;
+        }
         if (!checkRsync()) {
-            error('rsync is required. Install: brew install rsync');
+            error('rsync is required for sync on macOS/Linux. Install: brew install rsync (macOS) or your distro package.');
             process.exit(1);
         }
-        const localWpContent = join(instance.path, 'wp-content') + '/';
-        // If no cloud site specified, create one
         let site;
-        if (!cloudSiteArg) {
+        if (targetRef) {
+            // Push to an existing site: the explicit arg, or this instance's origin.
+            const spin = spinner('Resolving cloud site...');
+            spin.start();
+            try {
+                site = await resolveSite(targetRef);
+                spin.succeed(`Cloud site: ${site.name || site.sub_domain} (ID: ${site.id})`);
+            }
+            catch {
+                spin.fail('Site resolution failed');
+                process.exit(1);
+            }
+            if (!cloudSiteArg) {
+                info(`Pushing to the site this instance was cloned from (ID: ${site.id}). Pass a cloud site to override.`);
+            }
+            else if (!instance.cloudSiteId) {
+                // First explicit push from an instance with no recorded origin (e.g.
+                // cloned before linking existed): remember it so future bare pushes
+                // target this site instead of creating a new one. Don't overwrite an
+                // origin that's already set.
+                setLocalInstance({ ...instance, cloudSiteId: site.id, cloudSiteName: site.name || site.sub_domain || String(site.id) });
+            }
+        }
+        else {
+            // No arg and not a cloned instance — provision a new site named after
+            // the local instance.
             const spin = spinner('Creating cloud site...');
             spin.start();
             try {
                 const client = getClient();
-                const res = await client.post('/sites', { site_name: localName });
+                // Default to a reserved (permanent) site, consistent with `instawp create`.
+                const res = await client.post('/sites', { site_name: localName, is_reserved: true });
                 site = res.data?.data;
                 if (!site?.id)
                     throw new Error('Unexpected API response');
@@ -230,6 +291,9 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
                 }
                 // Re-resolve to get full details
                 site = await resolveSite(String(site.id));
+                // Link this instance to the site it just created, so subsequent
+                // pushes target it instead of creating yet another site.
+                setLocalInstance({ ...instance, cloudSiteId: site.id, cloudSiteName: site.name || site.sub_domain || String(site.id) });
             }
             catch (err) {
                 spin.fail('Failed to create cloud site');
@@ -237,18 +301,6 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
                 process.exit(1);
             }
         }
-        else {
-            const spin = spinner('Resolving cloud site...');
-            spin.start();
-            try {
-                site = await resolveSite(cloudSiteArg);
-                spin.succeed(`Cloud site: ${site.name || site.sub_domain} (ID: ${site.id})`);
-            }
-            catch {
-                spin.fail('Site resolution failed');
-                process.exit(1);
-            }
-        }
         // Get SSH access
         const conn = await ensureSshAccess(site.id);
         const remotePath = `/home/${conn.username}/web/${conn.domain}/public_html/wp-content/`;
@@ -266,22 +318,40 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
         info(`Pushing ${chalk.dim(localWpContent)} -> ${chalk.dim(conn.host + ':' + remotePath)}`);
         if (opts.dryRun)
             info('(dry run)');
-        const exitCode = rsyncViaSsh(conn, localWpContent, remoteTarget, extraArgs, !!opts.dryRun, true);
-        if (exitCode === 0) {
-            success('Push complete!');
-            if (site.url) {
-                console.log(`\n  ${chalk.dim('Cloud site:')} ${chalk.cyan.underline(site.url)}`);
-            }
-        }
-        else {
+        const exitCode = await syncFiles(conn, localWpContent, remoteTarget, extraArgs, !!opts.dryRun, true);
+        if (exitCode !== 0) {
             error(`rsync exited with code ${exitCode}`);
             process.exit(exitCode);
         }
+        // Optionally push the database too (OVERWRITES the cloud DB). Handles its
+        // own dry-run reporting and confirmation.
+        let dbStatus = null;
+        if (opts.withDb) {
+            dbStatus = await pushDatabase(instance, site, conn, opts);
+        }
+        // Dry-run output was already emitted by the file sync (and pushDatabase);
+        // don't print a misleading "complete".
+        if (opts.dryRun)
+            return;
+        if (dbStatus === 'cancelled') {
+            info('Files pushed. Database push was cancelled — the cloud database was not changed.');
+            if (site.url)
+                console.log(`\n  ${chalk.dim('Cloud site:')} ${chalk.cyan.underline(site.url)}`);
+            return;
+        }
+        success('Push complete!');
+        if (site.url) {
+            console.log(`\n  ${chalk.dim('Cloud site:')} ${chalk.cyan.underline(site.url)}`);
+        }
+        if (!opts.withDb) {
+            info('Files only. Database/content changes (pages, posts, settings) were NOT pushed — add --with-db to overwrite the cloud database.');
+        }
     });
     // local pull <local-name> <cloud-site>
     local
         .command('pull <local-name> <cloud-site>')
         .description('Pull wp-content from an InstaWP cloud site to local')
+        .option('--include <pattern...>', 'Include patterns (e.g. .git)')
         .option('--exclude <pattern...>', 'Additional exclude patterns')
         .option('--dry-run', 'Show what would be transferred')
         .action(async (localName, cloudSiteArg, opts) => {
@@ -292,7 +362,7 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
             process.exit(1);
         }
         if (!checkRsync()) {
-            error('rsync is required. Install: brew install rsync');
+            error('rsync is required for sync on macOS/Linux. Install: brew install rsync (macOS) or your distro package.');
             process.exit(1);
         }
         const localWpContent = join(instance.path, 'wp-content') + '/';
@@ -309,11 +379,14 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
         }
         const conn = await ensureSshAccess(site.id);
         const remotePath = `/home/${conn.username}/web/${conn.domain}/public_html/wp-content/`;
-        const extraArgs = [
-            '--exclude=database', // Don't overwrite local SQLite database
-            '--exclude=db.php',
-            '--exclude=mu-plugins',
-        ];
+        const extraArgs = [];
+        if (opts.include) {
+            for (const pattern of opts.include) {
+                extraArgs.push(`--include=${pattern}`);
+            }
+        }
+        extraArgs.push('--exclude=database', // Don't overwrite local SQLite database
+        '--exclude=db.php', '--exclude=mu-plugins');
         if (opts.exclude) {
             for (const pattern of opts.exclude) {
                 extraArgs.push(`--exclude=${pattern}`);
@@ -323,7 +396,7 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
         info(`Pulling ${chalk.dim(conn.host + ':' + remotePath)} -> ${chalk.dim(localWpContent)}`);
         if (opts.dryRun)
             info('(dry run)');
-        const exitCode = rsyncViaSsh(conn, remoteSource, localWpContent, extraArgs, !!opts.dryRun, true);
+        const exitCode = await syncFiles(conn, remoteSource, localWpContent, extraArgs, !!opts.dryRun, true);
         if (exitCode === 0) {
             success('Pull complete! Restart the local site to see changes.');
         }
@@ -338,10 +411,12 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
         .description('Clone a complete InstaWP cloud site to local')
         .option('--name <name>', 'Local instance name (defaults to cloud site name)')
         .option('--no-start', 'Do not start the local site after cloning')
+        .option('--force', 'Overwrite existing local instance')
+        .option('--include <pattern...>', 'Include patterns for rsync (e.g. .git)')
         .action(async (cloudSiteArg, opts) => {
         requireAuth();
         if (!checkRsync()) {
-            error('rsync is required. Install: brew install rsync');
+            error('rsync is required for sync on macOS/Linux. Install: brew install rsync (macOS) or your distro package.');
             process.exit(1);
         }
         // 1. Resolve cloud site
@@ -358,10 +433,17 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
         }
         // 2. Create local instance
         const instances = getLocalInstances();
-        const name = sanitizeName(opts.name || site.name || site.sub_domain || `site-${site.id}`);
+        const name = opts.name ? sanitizeName(opts.name) : defaultInstanceName(site);
         if (instances[name]) {
-            error(`Local instance "${name}" already exists. Use --name to pick a different name.`);
-            process.exit(1);
+            if (!opts.force) {
+                error(`Local instance "${name}" already exists. Use --force to overwrite or --name to pick a different name.`);
+                process.exit(1);
+            }
+            // Force: delete existing instance first
+            stopServerProcess(instances[name]);
+            deleteInstanceDir(name);
+            removeLocalInstance(name);
+            info(`Existing instance "${name}" removed.`);
         }
         const port = await getNextPort(instances);
         const dir = createInstanceDir(name);
@@ -372,6 +454,10 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
             wp: site.wp_version || 'latest',
             path: dir,
             createdAt: new Date().toISOString(),
+            // Remember the origin so `local push` (no arg) pushes back here instead
+            // of creating a new site.
+            cloudSiteId: site.id,
+            cloudSiteName: site.name || site.sub_domain || String(site.id),
         };
         setLocalInstance(instance);
         success(`Local instance "${name}" created`);
@@ -402,19 +488,26 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
         const remotePath = `/home/${conn.username}/web/${conn.domain}/public_html/wp-content/`;
         const remoteSource = `${conn.username}@${conn.host}:${remotePath}`;
         info(`Pulling wp-content from ${chalk.dim(conn.domain)}...`);
-        const rsyncExit = rsyncViaSsh(conn, remoteSource, localWpContent, [
+        const includeArgs = [];
+        if (opts.include) {
+            for (const pattern of opts.include) {
+                includeArgs.push(`--include=${pattern}`);
+            }
+        }
+        const rsyncExit = await syncFiles(conn, remoteSource, localWpContent, [
+            ...includeArgs,
             '--exclude=cache',
             '--exclude=upgrade',
             '--exclude=wflogs',
             '--exclude=backup*',
         ], false, true);
         if (rsyncExit !== 0) {
-            error(`wp-content sync failed (rsync exit code ${rsyncExit})`);
+            error(`wp-content sync failed (exit code ${rsyncExit})`);
         }
         // 5b. Pull non-core root files (CLAUDE.md, .htaccess, wp-cli.yml, etc.)
         const remoteRoot = `/home/${conn.username}/web/${conn.domain}/public_html/`;
         const rootRemote = `${conn.username}@${conn.host}:${remoteRoot}`;
-        rsyncViaSsh(conn, rootRemote, dir + '/', [
+        await syncFiles(conn, rootRemote, dir + '/', [
             '--exclude=wp-admin/',
             '--exclude=wp-includes/',
             '--exclude=wp-content/',
@@ -433,7 +526,7 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
             const dbSpin2 = spinner('Importing database...');
             dbSpin2.start();
             try {
-                const mysql2sqlitePath = resolve(join(new URL(import.meta.url).pathname, '..', '..', '..', 'scripts', 'mysql2sqlite'));
+                const mysql2sqlitePath = resolveFromModule(import.meta.url, '..', '..', 'scripts', 'mysql2sqlite');
                 const dbDir = join(dir, 'wp-content', 'database');
                 const sqliteDbPath = join(dbDir, '.ht.sqlite');
                 // Clean slate for database dir
@@ -446,8 +539,15 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
                 if (sqlStart > 0) {
                     writeFileSync(dumpPath, rawDump.substring(sqlStart));
                 }
-                // Convert MySQL → SQLite
-                const convertResult = spawnSync(mysql2sqlitePath, [dumpPath], {
+                // Convert MySQL → SQLite via awk (mysql2sqlite is an awk script).
+                // Windows doesn't honor shebangs, so invoke awk explicitly.
+                const awk = findAwk();
+                if (!awk) {
+                    throw new Error('awk not found. ' + (process.platform === 'win32'
+                        ? 'Reinstall the CLI — the bundled busybox.exe is missing.'
+                        : 'Install awk/gawk.'));
+                }
+                const convertResult = spawnSync(awk.cmd, [...awk.prefixArgs, '-f', mysql2sqlitePath, dumpPath], {
                     encoding: 'utf-8',
                     maxBuffer: 500 * 1024 * 1024,
                     timeout: 120000,
@@ -458,69 +558,54 @@ ${chalk.dim('#')} Data stored at: ${chalk.dim(dir)}
                 // Add DROP TABLE before each CREATE TABLE
                 let sqliteSql = convertResult.stdout;
                 sqliteSql = sqliteSql.replace(/^(CREATE TABLE `([^`]+)`)/gm, 'DROP TABLE IF EXISTS `$2`;\n$1');
-                // Write and import into SQLite
-                const tmpSql = join(dir, 'sqlite-import.sql');
-                writeFileSync(tmpSql, sqliteSql);
-                spawnSync('sqlite3', [sqliteDbPath], {
-                    input: `.read ${tmpSql}\n`,
-                    encoding: 'utf-8',
-                    timeout: 120000,
-                });
-                // Find the table prefix and rename to wp_
-                const tablesResult = spawnSync('sqlite3', [sqliteDbPath, '.tables'], { encoding: 'utf-8' });
-                const allTables = (tablesResult.stdout || '').split(/\s+/).filter(Boolean);
-                const optionsTable = allTables.find((t) => t.endsWith('_options'));
-                const oldPrefix = optionsTable ? optionsTable.replace('options', '') : 'wp_';
-                if (oldPrefix !== 'wp_') {
-                    // Rename tables
-                    const renameStatements = allTables
-                        .filter((t) => t.startsWith(oldPrefix))
-                        .map((t) => `ALTER TABLE \`${t}\` RENAME TO \`wp_${t.substring(oldPrefix.length)}\`;`)
-                        .join('\n');
-                    spawnSync('sqlite3', [sqliteDbPath, renameStatements], { encoding: 'utf-8' });
-                    // Rename meta keys and option names that contain the old prefix
-                    const fixPrefixSql = [
-                        `UPDATE wp_usermeta SET meta_key = REPLACE(meta_key, '${oldPrefix}', 'wp_') WHERE meta_key LIKE '${oldPrefix}%';`,
-                        `UPDATE wp_options SET option_name = REPLACE(option_name, '${oldPrefix}', 'wp_') WHERE option_name LIKE '${oldPrefix}%';`,
-                    ].join('\n');
-                    spawnSync('sqlite3', [sqliteDbPath, fixPrefixSql], { encoding: 'utf-8' });
-                }
-                // Search-replace old cloud URL → localhost
-                const localUrl = `http://127.0.0.1:${instance.port}`;
-                const oldDomain = site.url || site.sub_domain || '';
-                const oldUrls = [
-                    oldDomain,
-                    oldDomain.replace('https://', 'http://'),
-                ].filter(Boolean);
-                for (const oldUrl of oldUrls) {
-                    const replaceSql = [
-                        `UPDATE wp_options SET option_value = REPLACE(option_value, '${oldUrl}', '${localUrl}') WHERE option_value LIKE '%${oldUrl}%';`,
-                        `UPDATE wp_posts SET post_content = REPLACE(post_content, '${oldUrl}', '${localUrl}') WHERE post_content LIKE '%${oldUrl}%';`,
-                        `UPDATE wp_posts SET guid = REPLACE(guid, '${oldUrl}', '${localUrl}') WHERE guid LIKE '%${oldUrl}%';`,
-                        `UPDATE wp_postmeta SET meta_value = REPLACE(meta_value, '${oldUrl}', '${localUrl}') WHERE meta_value LIKE '%${oldUrl}%';`,
-                        `UPDATE wp_comments SET comment_content = REPLACE(comment_content, '${oldUrl}', '${localUrl}') WHERE comment_content LIKE '%${oldUrl}%';`,
-                    ].join('\n');
-                    spawnSync('sqlite3', [sqliteDbPath, replaceSql], { encoding: 'utf-8' });
-                }
-                // Ensure siteurl/home are correct
-                spawnSync('sqlite3', [sqliteDbPath,
-                    `UPDATE wp_options SET option_value='${localUrl}' WHERE option_name IN ('siteurl','home');`,
-                ], { encoding: 'utf-8' });
-                // Get admin username for blueprint login step
-                const adminResult = spawnSync('sqlite3', [sqliteDbPath,
-                    "SELECT user_login FROM wp_users WHERE ID = (SELECT user_id FROM wp_usermeta WHERE meta_key = 'wp_capabilities' AND meta_value LIKE '%administrator%' LIMIT 1);",
-                ], { encoding: 'utf-8' });
-                adminUsername = (adminResult.stdout || '').trim() || 'admin';
-                // Count tables for output
-                const countResult = spawnSync('sqlite3', [sqliteDbPath,
-                    "SELECT COUNT(*) FROM sqlite_master WHERE type='table';",
-                ], { encoding: 'utf-8' });
-                // Clean up temp file
+                // Import directly via better-sqlite3 (no external sqlite3 CLI needed)
+                const db = new Database(sqliteDbPath);
                 try {
-                    rmSync(tmpSql);
+                    db.exec(sqliteSql);
+                    // Find the table prefix and rename to wp_
+                    const tableRows = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+                    const allTables = tableRows.map(r => r.name);
+                    const optionsTable = allTables.find(t => t.endsWith('_options'));
+                    const oldPrefix = optionsTable ? optionsTable.replace('options', '') : 'wp_';
+                    if (oldPrefix !== 'wp_') {
+                        const renames = allTables
+                            .filter(t => t.startsWith(oldPrefix))
+                            .map(t => `ALTER TABLE \`${t}\` RENAME TO \`wp_${t.substring(oldPrefix.length)}\``);
+                        db.exec(renames.join(';\n') + ';');
+                        // Rename meta keys and option names that contain the old prefix
+                        db.prepare('UPDATE wp_usermeta SET meta_key = REPLACE(meta_key, ?, ?) WHERE meta_key LIKE ?').run(oldPrefix, 'wp_', oldPrefix + '%');
+                        db.prepare('UPDATE wp_options SET option_name = REPLACE(option_name, ?, ?) WHERE option_name LIKE ?').run(oldPrefix, 'wp_', oldPrefix + '%');
+                    }
+                    // Search-replace old cloud URL → localhost (bound params: no SQL injection)
+                    const localUrl = `http://127.0.0.1:${instance.port}`;
+                    const oldDomain = site.url || site.sub_domain || '';
+                    const oldUrls = [
+                        oldDomain,
+                        oldDomain.replace('https://', 'http://'),
+                    ].filter(Boolean);
+                    const replaceStmts = [
+                        'UPDATE wp_options SET option_value = REPLACE(option_value, ?, ?) WHERE option_value LIKE ?',
+                        'UPDATE wp_posts SET post_content = REPLACE(post_content, ?, ?) WHERE post_content LIKE ?',
+                        'UPDATE wp_posts SET guid = REPLACE(guid, ?, ?) WHERE guid LIKE ?',
+                        'UPDATE wp_postmeta SET meta_value = REPLACE(meta_value, ?, ?) WHERE meta_value LIKE ?',
+                        'UPDATE wp_comments SET comment_content = REPLACE(comment_content, ?, ?) WHERE comment_content LIKE ?',
+                    ].map(s => db.prepare(s));
+                    for (const oldUrl of oldUrls) {
+                        const likePattern = '%' + oldUrl + '%';
+                        for (const stmt of replaceStmts) {
+                            stmt.run(oldUrl, localUrl, likePattern);
+                        }
+                    }
+                    db.prepare("UPDATE wp_options SET option_value = ? WHERE option_name IN ('siteurl','home')").run(localUrl);
+                    // Get admin username for blueprint login step
+                    const adminRow = db.prepare("SELECT user_login FROM wp_users WHERE ID = (SELECT user_id FROM wp_usermeta WHERE meta_key = 'wp_capabilities' AND meta_value LIKE '%administrator%' LIMIT 1)").get();
+                    adminUsername = adminRow?.user_login || 'admin';
+                    const tableCount = db.prepare("SELECT COUNT(*) AS c FROM sqlite_master WHERE type='table'").get().c;
+                    dbSpin2.succeed(`Database imported (${tableCount} tables, admin: ${adminUsername})`);
+                }
+                finally {
+                    db.close();
                 }
-                catch { }
-                dbSpin2.succeed(`Database imported (${(countResult.stdout || '').trim()} tables, admin: ${adminUsername})`);
             }
             catch (err) {
                 dbSpin2.fail('Database import failed: ' + err.message);
@@ -578,12 +663,294 @@ ${chalk.bold.green('Clone complete!')}
         }
     });
 }
+/** True if a URL is a plain http(s) URL safe to embed in a single-quoted shell arg. */
+function isShellSafeUrl(u) {
+    return /^https?:\/\/[^\s'"\\$`]+$/.test(u);
+}
+/**
+ * Push the local Playground SQLite database to the cloud site's MySQL, OVERWRITING
+ * it. Steps: read the local site URL, discover the cloud table prefix + existing
+ * tables, generate a data-only MySQL dump (TRUNCATE+INSERT for tables present on
+ * both), back up the cloud DB, upload + import, then `wp search-replace` the URL
+ * (serialization-safe). Honors --dry-run / --no-backup / --force.
+ */
+async function pushDatabase(instance, site, conn, opts) {
+    const sqlitePath = join(instance.path, 'wp-content', 'database', '.ht.sqlite');
+    if (!existsSync(sqlitePath)) {
+        error('No local database found (expected wp-content/database/.ht.sqlite). Skipping DB push.');
+        process.exit(1);
+    }
+    const wpPath = `/home/${conn.username}/web/${conn.domain}/public_html`;
+    // Authoritative local URL from the DB (handles port drift); cloud URL from the site.
+    let fromUrl = `http://127.0.0.1:${instance.port}`;
+    try {
+        const ldb = new Database(sqlitePath, { readonly: true });
+        try {
+            const row = ldb.prepare("SELECT option_value AS v FROM wp_options WHERE option_name='siteurl'").get();
+            if (row?.v)
+                fromUrl = String(row.v).replace(/\/+$/, '');
+        }
+        finally {
+            ldb.close();
+        }
+    }
+    catch { /* fall back to the constructed local URL */ }
+    const toUrl = String(site.url || `https://${conn.domain}`).replace(/\/+$/, '');
+    // Destructive confirmation (skipped on --force; --json requires --force).
+    if (!opts.force && !opts.dryRun) {
+        if (isJsonMode()) {
+            error('--force is required with --with-db in --json mode (cannot prompt before overwriting the cloud DB).');
+            process.exit(1);
+        }
+        const backupLine = opts.backup !== false
+            ? `The cloud DB will be backed up to ~/db-backup-<ts>.sql.gz first.`
+            : chalk.red('NO cloud backup will be taken (--no-backup). This is irreversible.');
+        console.log(`\nThis will ${chalk.bold.red('OVERWRITE')} the database on ${chalk.bold(conn.domain)} with your local data.`);
+        console.log(backupLine);
+        const readline = await import('node:readline');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ans = await new Promise((r) => rl.question('Continue? (y/N) ', r));
+        rl.close();
+        const yes = ans.trim().toLowerCase();
+        if (yes !== 'y' && yes !== 'yes') {
+            return 'cancelled';
+        }
+    }
+    // Discover cloud prefix + existing tables so we only TRUNCATE/INSERT tables
+    // that exist there (a missing-table TRUNCATE would abort the whole import).
+    const inspectSpin = spinner('Inspecting cloud database...');
+    inspectSpin.start();
+    // Parse discovery output defensively — InstaWP SSH prepends a login banner to
+    // non-interactive stdout (the clone flow strips the same banner). A banner
+    // leaking into the prefix would mismatch every table and silently push nothing.
+    const prefixRes = execViaSsh(conn, `cd ${wpPath} && wp config get table_prefix`);
+    const cloudPrefix = parseTablePrefix(prefixRes.exitCode === 0 ? prefixRes.stdout : '', 'wp_');
+    const tablesRes = execViaSsh(conn, `cd ${wpPath} && wp db query 'SHOW TABLES' --skip-column-names`);
+    if (tablesRes.exitCode !== 0) {
+        inspectSpin.fail('Could not read the cloud database');
+        if (tablesRes.stderr)
+            error(tablesRes.stderr.trim());
+        process.exit(1);
+    }
+    const cloudTables = parseSqlTableNames(tablesRes.stdout);
+    inspectSpin.succeed(`Cloud DB: prefix "${cloudPrefix}", ${cloudTables.size} tables`);
+    // Generate the data-only MySQL dump from local SQLite.
+    const localDumpPath = join(tmpdir(), `instawp-localpush-${randomBytes(6).toString('hex')}.sql`);
+    const genSpin = spinner('Generating database dump...');
+    genSpin.start();
+    let dump;
+    try {
+        dump = generateMysqlDump({ sqlitePath, cloudPrefix, cloudTables, outPath: localDumpPath });
+    }
+    catch (err) {
+        genSpin.fail('Failed to generate the database dump');
+        error(err?.message || String(err));
+        try {
+            unlinkSync(localDumpPath);
+        }
+        catch { /* ignore */ }
+        process.exit(1);
+    }
+    genSpin.succeed(`Dump ready: ${dump.tables.length} table(s), ${dump.totalRows} row(s)` +
+        (dump.skipped.length ? ` (skipped ${dump.skipped.length} local-only table(s))` : ''));
+    // Cloud tables (with the cloud prefix) that have no local counterpart — they
+    // keep their existing data on an overwrite. Surface them so it's not surprising.
+    const dumpedCloud = new Set(dump.tables.map((t) => t.cloud));
+    const untouched = [...cloudTables].filter((t) => t.startsWith(cloudPrefix) && !dumpedCloud.has(t));
+    // Dry run: report and stop (no cloud writes).
+    if (opts.dryRun) {
+        if (isJsonMode()) {
+            console.log(JSON.stringify({ success: true, dry_run: true, db: { from_url: fromUrl, to_url: toUrl, tables: dump.tables, skipped: dump.skipped, untouched, total_rows: dump.totalRows } }));
+        }
+        else {
+            info(`(dry run) Would OVERWRITE the cloud DB on ${conn.domain}:`);
+            for (const t of dump.tables)
+                console.log(`  ${chalk.dim('•')} ${t.cloud} (${t.rows} rows)`);
+            if (dump.skipped.length)
+                info(`(dry run) Skipped local-only tables: ${dump.skipped.join(', ')}`);
+            if (untouched.length)
+                info(`(dry run) Cloud tables kept as-is (no local counterpart): ${untouched.join(', ')}`);
+            if (fromUrl !== toUrl)
+                info(`(dry run) Then: wp search-replace ${fromUrl} ${toUrl}`);
+        }
+        try {
+            unlinkSync(localDumpPath);
+        }
+        catch { /* ignore */ }
+        return 'dry';
+    }
+    // Refuse to push an empty dump: if nothing intersected, the cloud discovery
+    // (prefix/tables) almost certainly went wrong — overwriting would be a silent
+    // no-op that looks successful. Fail loud and change nothing.
+    if (dump.tables.length === 0) {
+        error(`No local tables matched the cloud database (cloud prefix "${cloudPrefix}", ${cloudTables.size} cloud tables). Refusing to push an empty database — nothing was changed.`);
+        try {
+            unlinkSync(localDumpPath);
+        }
+        catch { /* ignore */ }
+        process.exit(1);
+    }
+    if (untouched.length) {
+        info(`${untouched.length} cloud table(s) have no local counterpart and will KEEP their existing data: ${untouched.slice(0, 8).join(', ')}${untouched.length > 8 ? ', …' : ''}`);
+    }
+    // Back up the cloud DB first (unless --no-backup). Random suffix so same-second
+    // reruns never clobber a prior backup.
+    const takeBackup = opts.backup !== false;
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').replace(/-\d{3}Z$/, '');
+    const backupFilename = `db-backup-${ts}-${randomBytes(3).toString('hex')}.sql.gz`;
+    const backupRemotePath = `/home/${conn.username}/${backupFilename}`;
+    if (takeBackup) {
+        const bSpin = spinner(`Backing up cloud database to ~/${backupFilename}...`);
+        bSpin.start();
+        const bRes = execViaSsh(conn, `cd ${wpPath} && wp db export --single-transaction - | gzip > ${backupRemotePath}`);
+        if (bRes.exitCode !== 0) {
+            bSpin.fail('Cloud DB backup failed — aborting DB push');
+            if (bRes.stderr)
+                error(bRes.stderr.trim());
+            try {
+                unlinkSync(localDumpPath);
+            }
+            catch { /* ignore */ }
+            process.exit(1);
+        }
+        bSpin.succeed(`Cloud DB backed up: ~/${backupFilename}`);
+    }
+    else {
+        info('Skipping cloud DB backup (--no-backup).');
+    }
+    // Upload + import.
+    const remoteTmp = `/tmp/instawp-dbimport-${randomBytes(6).toString('hex')}.sql`;
+    const upSpin = spinner('Uploading database dump...');
+    upSpin.start();
+    const scpExit = scpUpload(conn, localDumpPath, remoteTmp);
+    try {
+        unlinkSync(localDumpPath);
+    }
+    catch { /* ignore */ }
+    if (scpExit !== 0) {
+        upSpin.fail(`Upload failed (scp exit ${scpExit})`);
+        if (takeBackup)
+            info(`Cloud backup preserved: ~/${backupFilename}`);
+        process.exit(1);
+    }
+    upSpin.succeed('Upload complete');
+    const impSpin = spinner(`Importing database on ${conn.domain}...`);
+    impSpin.start();
+    const impRes = execViaSsh(conn, `cd ${wpPath} && wp db import ${remoteTmp}`);
+    if (impRes.exitCode !== 0) {
+        impSpin.fail('Database import failed');
+        if (impRes.stderr)
+            error(impRes.stderr.trim());
+        else if (impRes.stdout)
+            error(impRes.stdout.trim());
+        execViaSsh(conn, `rm -f ${remoteTmp}`);
+        if (takeBackup) {
+            info(`Cloud backup preserved at ~/${backupFilename}. Restore it with:`);
+            console.log(`  ssh ${conn.username}@${conn.host} 'cd ${wpPath} && gunzip -c ${backupRemotePath} | wp db import -'`);
+        }
+        else {
+            error('No backup was taken — the cloud database may be inconsistent.');
+        }
+        process.exit(1);
+    }
+    impSpin.succeed('Database imported');
+    // Remap table-prefix-embedded role/capability keys. WordPress stores these
+    // under the table prefix: wp_usermeta.{prefix}capabilities / {prefix}user_level
+    // and wp_options.{prefix}user_roles. The local DB uses the `wp_` prefix, so the
+    // imported keys are `wp_capabilities` etc.; if the cloud prefix differs, the
+    // admin user has NO capabilities and wp-admin becomes inaccessible. Rewrite the
+    // access-critical keys (exact names — safe, never touches plugin options) to the
+    // cloud prefix. (clone does the inverse when pulling down.)
+    if (cloudPrefix !== 'wp_') {
+        const capSpin = spinner('Remapping user roles/capabilities to the cloud prefix...');
+        capSpin.start();
+        const um = `${cloudPrefix}usermeta`;
+        const opt = `${cloudPrefix}options`;
+        const stmts = [
+            `UPDATE ${um} SET meta_key='${cloudPrefix}capabilities' WHERE meta_key='wp_capabilities'`,
+            `UPDATE ${um} SET meta_key='${cloudPrefix}user_level' WHERE meta_key='wp_user_level'`,
+            `UPDATE ${opt} SET option_name='${cloudPrefix}user_roles' WHERE option_name='wp_user_roles'`,
+        ];
+        let capOk = true;
+        for (const s of stmts) {
+            const r = execViaSsh(conn, `cd ${wpPath} && wp db query "${s}"`);
+            if (r.exitCode !== 0) {
+                capOk = false;
+                if (r.stderr)
+                    error(r.stderr.trim());
+            }
+        }
+        if (capOk)
+            capSpin.succeed('Roles/capabilities remapped to cloud prefix');
+        else
+            capSpin.fail('Could not remap roles/capabilities — wp-admin access may need a manual fix');
+    }
+    // Rewrite local URL → cloud URL, serialization-safe via wp-cli.
+    if (fromUrl !== toUrl) {
+        if (isShellSafeUrl(fromUrl) && isShellSafeUrl(toUrl)) {
+            const srSpin = spinner(`Rewriting URLs (${fromUrl} → ${toUrl})...`);
+            srSpin.start();
+            const srRes = execViaSsh(conn, `cd ${wpPath} && wp search-replace '${fromUrl}' '${toUrl}' --all-tables --report-changed-only`);
+            if (srRes.exitCode !== 0) {
+                srSpin.fail('URL rewrite failed (DB imported; run search-replace manually if links are wrong)');
+                if (srRes.stderr)
+                    error(srRes.stderr.trim());
+            }
+            else {
+                srSpin.succeed('URLs rewritten');
+            }
+        }
+        else {
+            info(`Skipped URL rewrite (unsafe URL). Run manually: wp search-replace '<local>' '${toUrl}' --all-tables`);
+        }
+    }
+    // Flush caches + clean up remote temp (best effort).
+    execViaSsh(conn, `cd ${wpPath} && wp cache flush`);
+    execViaSsh(conn, `rm -f ${remoteTmp}`);
+    if (takeBackup)
+        info(`Cloud DB backup kept at ~/${backupFilename} (on remote).`);
+    return 'done';
+}
 function checkRsync() {
+    // Windows transfers go over pure-JS SFTP, so rsync isn't required there.
+    if (process.platform === 'win32')
+        return true;
     const result = spawnSync('which', ['rsync'], { stdio: 'ignore' });
     return result.status === 0;
 }
-function sanitizeName(name) {
-    return name.replace(/[^a-zA-Z0-9_-]/g, '-').toLowerCase();
+/**
+ * Locate an awk-compatible interpreter. Resolution order:
+ *   1. Bundled BusyBox-w64 in bin/win32/ (Windows only — invoked as `busybox awk`)
+ *   2. `awk` or `gawk` in PATH
+ *   3. Common Git-for-Windows install dirs (Windows only)
+ *
+ * Returns the command path plus any arg-prefix that must precede the awk
+ * arguments (busybox uses `busybox awk -f script input`).
+ */
+function findAwk() {
+    const bb = bundledBusybox();
+    if (bb)
+        return { cmd: bb, prefixArgs: ['awk'] };
+    const cmd = process.platform === 'win32' ? 'where' : 'which';
+    for (const name of ['awk', 'gawk']) {
+        const r = spawnSync(cmd, [name], { stdio: 'pipe' });
+        if (r.status === 0)
+            return { cmd: name, prefixArgs: [] };
+    }
+    if (process.platform === 'win32') {
+        const candidates = [
+            'C:\\Program Files\\Git\\usr\\bin\\awk.exe',
+            'C:\\Program Files (x86)\\Git\\usr\\bin\\awk.exe',
+        ];
+        if (process.env.PROGRAMFILES) {
+            candidates.push(process.env.PROGRAMFILES + '\\Git\\usr\\bin\\awk.exe');
+        }
+        for (const c of candidates) {
+            if (existsSync(c))
+                return { cmd: c, prefixArgs: [] };
+        }
+    }
+    return null;
 }
 // Playground supports: 7.4, 8.0, 8.1, 8.2, 8.3, 8.4, 8.5
 const PLAYGROUND_PHP_VERSIONS = ['7.4', '8.0', '8.1', '8.2', '8.3', '8.4', '8.5'];
@@ -611,27 +978,51 @@ function printUrls(port) {
 }
 async function launchServer(instance, opts) {
     const shouldOpen = opts.open !== false;
+    const json = isJsonMode();
     if (opts.background) {
-        const spin = spinner(`Starting "${instance.name}" in background...`);
-        spin.start();
+        const spin = json ? null : spinner(`Starting "${instance.name}" in background...`);
+        spin?.start();
         try {
             const { pid, url } = await startServerBackground(instance, opts.blueprint);
-            spin.succeed(`Running in background (PID: ${pid})`);
-            printUrls(instance.port);
+            if (json) {
+                console.log(JSON.stringify({
+                    success: true,
+                    data: {
+                        name: instance.name,
+                        url,
+                        port: instance.port,
+                        pid,
+                        wp: instance.wp,
+                        php: instance.php,
+                        path: instance.path,
+                    },
+                }));
+            }
+            else {
+                spin?.succeed(`Running in background (PID: ${pid})`);
+                printUrls(instance.port);
+                info(`Stop with: instawp local stop ${instance.name}`);
+                info(`Logs: ${instance.path}/server.log`);
+            }
             if (shouldOpen)
                 await openWpAdmin(url);
-            info(`Stop with: instawp local stop ${instance.name}`);
-            info(`Logs: ${instance.path}/server.log`);
         }
         catch (err) {
-            spin.fail('Failed to start');
-            error(err.message);
+            if (json) {
+                console.log(JSON.stringify({ success: false, error: err.message }));
+            }
+            else {
+                spin?.fail('Failed to start');
+                error(err.message);
+            }
             process.exit(1);
         }
     }
     else {
-        printUrls(instance.port);
-        console.log(chalk.dim('\nPress Ctrl+C to stop.\n'));
+        if (!json) {
+            printUrls(instance.port);
+            console.log(chalk.dim('\nPress Ctrl+C to stop.\n'));
+        }
         try {
             await startServer(instance, {
                 blueprint: opts.blueprint,