@wordpress-flow/cli 1.2.12 → 1.2.13

package/dist/index.js

@@ -80975,6 +80975,16 @@ class ConfigManager {
     }
     return result2;
   }
+  getRawConfig() {
+    if (!this.rawConfig) {
+      throw new Error("Configuration not loaded. Call loadConfig() first.");
+    }
+    return this.rawConfig;
+  }
+  getEnvironments() {
+    const raw = this.getRawConfig();
+    return raw.environments || [];
+  }
   getConfig() {
     if (!this.config) {
       throw new Error("Configuration not loaded. Call loadConfig() first.");
@@ -81126,6 +81136,9 @@ class Logger {
   step(step, total, message) {
     console.log(import_chalk2.default.cyan(`[${step}/${total}] ${message}`));
   }
+  substep(message) {
+    console.log(import_chalk2.default.gray(`  ↳ ${message}`));
+  }
 }
 var logger = Logger.getInstance();
 // src/commands/pull-command.ts
@@ -114937,10 +114950,6 @@ class BlockHashManager {
       logger.debug(`${blockName}: No stored hash, needs rebuild`);
       return true;
     }
-    if (storedHash.cliVersion !== this.cliVersion) {
-      logger.debug(`${blockName}: CLI version changed, needs rebuild`);
-      return true;
-    }
     const currentHash = this.calculateSourceHash(sourcePath);
     if (!currentHash) {
       logger.debug(`${blockName}: Source file missing, needs rebuild`);
@@ -116186,7 +116195,7 @@ class DockerEnvManager {
 // package.json
 var package_default = {
   name: "@wordpress-flow/cli",
-  version: "1.2.12",
+  version: "1.2.13",
   type: "module",
   description: "TypeScript-based WordPress block creation system",
   main: "dist/index.js",
@@ -117159,6 +117168,7 @@ class DevCommand {
 
 // src/commands/build-command.ts
 import * as path22 from "path";
+import * as fs19 from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/build/block-builder.ts
@@ -117751,6 +117761,12 @@ class WorkerPool {
 // src/commands/build-command.ts
 var __filename3 = fileURLToPath5(import.meta.url);
 var __dirname3 = path22.dirname(__filename3);
+var packageJsonPath = path22.join(__dirname3, "..", "..", "..", "package.json");
+var packageVersion = "1.2.12";
+try {
+  const packageJson = JSON.parse(fs19.readFileSync(packageJsonPath, "utf8"));
+  packageVersion = packageJson.version;
+} catch {}
 
 class BuildCommand {
   configManager;
@@ -117759,6 +117775,7 @@ class BuildCommand {
   typeGenerator;
   phpGenerator;
   blockScripts;
+  hashManager = null;
   constructor() {
     this.configManager = ConfigManager.getInstance();
     this.blockScanner = new BlockScanner;
@@ -117809,6 +117826,27 @@ class BuildCommand {
       } else {
         logger.info(`Found ${blocks.length} block(s): ${blocks.map((b) => b.name).join(", ")}`);
       }
+      this.hashManager = new BlockHashManager(outputDir, packageVersion);
+      let blocksToRebuild = blocks;
+      if (!options.noCache) {
+        const stats = this.hashManager.getStats(blocks);
+        if (stats.cached > 0) {
+          logger.info(`\uD83D\uDCE6 Cache: ${stats.cached} block(s) unchanged, ${stats.needsRebuild} need(s) rebuild`);
+          blocksToRebuild = this.hashManager.filterBlocksNeedingRebuild(blocks);
+          const skippedBlocks = blocks.filter((b) => !blocksToRebuild.find((rb) => rb.name === b.name));
+          if (skippedBlocks.length > 0) {
+            logger.info(`⏭️  Skipping: ${skippedBlocks.map((b) => b.name).join(", ")}`);
+          }
+        }
+      } else {
+        logger.info("\uD83D\uDD04 Cache disabled (--no-cache), rebuilding all blocks");
+        this.hashManager.clearAllHashes();
+      }
+      if (blocksToRebuild.length === 0) {
+        logger.success("✨ All blocks are up to date! Nothing to build.");
+        return;
+      }
+      logger.info(`\uD83D\uDD28 Building ${blocksToRebuild.length} block(s): ${blocksToRebuild.map((b) => b.name).join(", ")}`);
       const scriptsOutputDir = this.configManager.resolvePath(config.paths.scriptsDist);
       const workerPool = new WorkerPool({
         concurrency: options.concurrency,
@@ -117817,9 +117855,14 @@ class BuildCommand {
         webpackConfigPath: webpackConfig,
         scriptsPath
       });
-      const results = await workerPool.buildAll(blocks, (completed, total, blockName, success, error) => {
+      const results = await workerPool.buildAll(blocksToRebuild, (completed, total, blockName, success, error) => {
         if (success) {
           logger.success(`✅ Built: ${blockName} [${completed}/${total}]`);
+          const block = blocksToRebuild.find((b) => b.name === blockName);
+          if (block && this.hashManager) {
+            const sourceHash = this.hashManager.calculateSourceHash(block.filePath);
+            this.hashManager.storeHash(blockName, sourceHash);
+          }
         } else {
           logger.error(`❌ Failed: ${blockName} [${completed}/${total}]: ${error || "unknown error"}`);
         }
@@ -117848,11 +117891,17 @@ Failed to build ${failures.length} block(s):`);
       }
       await this.generateTypeDefinitions(outputDir);
       const successCount = results.filter((r) => r.success).length;
+      const totalBlocks = blocks.length;
+      const cachedCount = totalBlocks - blocksToRebuild.length;
       if (failures.length > 0) {
-        logger.warn(`Build completed with errors. Built ${successCount}/${blocks.length} block(s).`);
+        logger.warn(`Build completed with errors. Built ${successCount}/${blocksToRebuild.length} block(s)${cachedCount > 0 ? `, ${cachedCount} cached` : ""}.`);
         process.exit(1);
       } else {
-        logger.success(`Build completed successfully! Built ${successCount} block(s).`);
+        if (cachedCount > 0) {
+          logger.success(`Build completed successfully! Built ${successCount} block(s), ${cachedCount} cached.`);
+        } else {
+          logger.success(`Build completed successfully! Built ${successCount} block(s).`);
+        }
       }
     } catch (error) {
       logger.error("Build operation failed:");
@@ -117881,7 +117930,7 @@ Failed to build ${failures.length} block(s):`);
 }
 
 // src/commands/build-templates-command.ts
-import * as fs19 from "fs";
+import * as fs20 from "fs";
 import * as path23 from "path";
 class BuildTemplatesCommand {
   configManager;
@@ -117893,11 +117942,11 @@ class BuildTemplatesCommand {
     const config = this.configManager.getConfig();
     const templatesDir = options.templatesDir || this.configManager.resolvePath(config.paths.templates);
     const outputDir = options.outputDir || this.configManager.resolvePath(config.paths.templatesOutput);
-    if (!fs19.existsSync(templatesDir)) {
+    if (!fs20.existsSync(templatesDir)) {
       logger.error(`Templates directory not found: ${templatesDir}`);
       return;
     }
-    fs19.mkdirSync(outputDir, { recursive: true });
+    fs20.mkdirSync(outputDir, { recursive: true });
     const blocksOutputDir = this.configManager.resolvePath(config.paths.blocksDist);
     const blockRegistry = new BlockRegistry(blocksOutputDir);
     await blockRegistry.loadBuiltBlocks();
@@ -117935,17 +117984,17 @@ class BuildTemplatesCommand {
     }
   }
   async buildTemplate(templatePath, templateName, outputDir, renderer) {
-    const mdxContent = fs19.readFileSync(templatePath, "utf8");
+    const mdxContent = fs20.readFileSync(templatePath, "utf8");
     const cleanContent = this.removeFrontmatter(mdxContent);
     const html5 = await renderer.renderMDXToHTML(cleanContent);
     const cleanHTML = renderer.postProcessHTML(html5);
     const outputPath = path23.join(outputDir, `${templateName}.html`);
-    fs19.writeFileSync(outputPath, cleanHTML, "utf8");
+    fs20.writeFileSync(outputPath, cleanHTML, "utf8");
     logger.info(`✓ Generated: ${path23.relative(process.cwd(), outputPath)}`);
   }
   findMDXFiles(dir) {
     const files = [];
-    const entries = fs19.readdirSync(dir, { withFileTypes: true });
+    const entries = fs20.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path23.join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -117963,7 +118012,7 @@ class BuildTemplatesCommand {
 }
 
 // src/commands/env-command.ts
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 import * as path24 from "path";
 class EnvCommand {
   configManager;
@@ -117972,11 +118021,11 @@ class EnvCommand {
   }
   getDockerEnvManager() {
     const config = this.configManager.getConfig();
-    const packageJsonPath = path24.join(this.configManager.getConfigDir(), "package.json");
+    const packageJsonPath2 = path24.join(this.configManager.getConfigDir(), "package.json");
     let projectName = "wordpress-project";
-    if (fs20.existsSync(packageJsonPath)) {
+    if (fs21.existsSync(packageJsonPath2)) {
       try {
-        const pkg = JSON.parse(fs20.readFileSync(packageJsonPath, "utf8"));
+        const pkg = JSON.parse(fs21.readFileSync(packageJsonPath2, "utf8"));
         projectName = pkg.name || projectName;
       } catch {}
     }
@@ -118025,6 +118074,501 @@ class EnvCommand {
   }
 }
 
+// src/commands/deploy-command.ts
+import * as fs23 from "fs";
+import * as path26 from "path";
+
+// src/wordpress/ssh-tunnel.ts
+import * as fs22 from "fs";
+import * as path25 from "path";
+import { spawn } from "child_process";
+class SSHTunnel {
+  configManager;
+  secrets = new Map;
+  tunnelProcess = null;
+  constructor() {
+    this.configManager = ConfigManager.getInstance();
+    this.loadSecrets();
+  }
+  loadSecrets() {
+    const secretsPath = path25.join(process.cwd(), "wordpress-flow.secrets");
+    if (!fs22.existsSync(secretsPath))
+      return;
+    try {
+      const content4 = fs22.readFileSync(secretsPath, "utf8");
+      for (const line of content4.split(`
+`)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+          continue;
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex === -1)
+          continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        this.secrets.set(key, value);
+      }
+    } catch {}
+  }
+  resolveVariables(value) {
+    return value.replace(/\$\{([^}]+)\}/g, (match2, varName) => {
+      const secret = this.secrets.get(varName);
+      if (secret !== undefined)
+        return secret;
+      const envVar = process.env[varName];
+      if (envVar !== undefined)
+        return envVar;
+      return match2;
+    });
+  }
+  getEnvironment(name2) {
+    const environments = this.configManager.getEnvironments();
+    const env2 = environments.find((e) => e.name === name2);
+    if (!env2) {
+      throw new Error(`Environment "${name2}" not found. Available: ${environments.map((e) => e.name).join(", ")}`);
+    }
+    return env2;
+  }
+  async connect(envName) {
+    const env2 = this.getEnvironment(envName);
+    if (!env2.database) {
+      throw new Error(`No database config for environment "${envName}"`);
+    }
+    const db = env2.database;
+    const dbHost = this.resolveVariables(db.host);
+    const dbPort = db.port || 3306;
+    const dbUser = this.resolveVariables(db.username);
+    const dbPass = this.resolveVariables(db.password);
+    const dbName = this.resolveVariables(db.database);
+    const localPort = 13306 + Math.floor(Math.random() * 1000);
+    const sshPort = env2.ssh.port || 22;
+    const target = `${env2.ssh.user}@${env2.ssh.host}`;
+    let sshFlags = `-p ${sshPort} -o ServerAliveInterval=30 -o StrictHostKeyChecking=no`;
+    let prefix = "";
+    if (env2.ssh.privateKeyPath) {
+      sshFlags += ` -i ${this.resolveVariables(env2.ssh.privateKeyPath)}`;
+    } else if (env2.ssh.password) {
+      const password = this.resolveVariables(env2.ssh.password);
+      const escaped = password.replace(/'/g, "'\\''");
+      prefix = `sshpass -p '${escaped}' `;
+      sshFlags += ` -o PreferredAuthentications=password -o PubkeyAuthentication=no`;
+    }
+    const tunnelCmd = `${prefix}ssh ${sshFlags} -N -L ${localPort}:${dbHost}:${dbPort} ${target}`;
+    logger.substep(`SSH tunnel: localhost:${localPort} → ${envName} (${dbHost}:${dbPort})`);
+    this.tunnelProcess = spawn("bash", ["-c", tunnelCmd], {
+      stdio: "pipe",
+      detached: false
+    });
+    await this.waitForPort(localPort, 15000);
+    this.configManager.setDatabaseConnection({
+      host: "127.0.0.1",
+      port: localPort,
+      database: dbName,
+      username: dbUser,
+      password: dbPass
+    });
+    return () => {
+      this.tunnelProcess?.kill();
+      this.tunnelProcess = null;
+    };
+  }
+  waitForPort(port, timeoutMs) {
+    const net = __require("net");
+    const start2 = Date.now();
+    return new Promise((resolve7, reject) => {
+      const tryConnect = () => {
+        if (Date.now() - start2 > timeoutMs) {
+          return reject(new Error(`SSH tunnel timed out — port ${port} not reachable after ${timeoutMs / 1000}s`));
+        }
+        const socket = net.createConnection({ port, host: "127.0.0.1" });
+        socket.setTimeout(500);
+        socket.on("connect", () => {
+          socket.destroy();
+          resolve7();
+        });
+        socket.on("error", () => {
+          socket.destroy();
+          setTimeout(tryConnect, 300);
+        });
+        socket.on("timeout", () => {
+          socket.destroy();
+          setTimeout(tryConnect, 300);
+        });
+      };
+      tryConnect();
+    });
+  }
+}
+
+// src/commands/deploy-command.ts
+import { execSync as execSync3 } from "child_process";
+
+class DeployCommand {
+  configManager;
+  secrets = new Map;
+  constructor() {
+    this.configManager = ConfigManager.getInstance();
+    this.loadSecrets();
+  }
+  loadSecrets() {
+    const secretsPath = path26.join(process.cwd(), "wordpress-flow.secrets");
+    if (!fs23.existsSync(secretsPath)) {
+      logger.debug("No secrets file found at wordpress-flow.secrets");
+      return;
+    }
+    try {
+      const content4 = fs23.readFileSync(secretsPath, "utf8");
+      for (const line of content4.split(`
+`)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+          continue;
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex === -1)
+          continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        this.secrets.set(key, value);
+      }
+      logger.debug(`Loaded ${this.secrets.size} secrets`);
+    } catch (error) {
+      logger.warn(`Failed to load secrets: ${error.message}`);
+    }
+  }
+  resolveVariables(value) {
+    return value.replace(/\$\{([^}]+)\}/g, (match2, varName) => {
+      const secret = this.secrets.get(varName);
+      if (secret !== undefined)
+        return secret;
+      const envVar = process.env[varName];
+      if (envVar !== undefined)
+        return envVar;
+      logger.warn(`Variable ${varName} not found in secrets or environment`);
+      return match2;
+    });
+  }
+  buildSSHConfig(env2) {
+    return `${env2.ssh.user}@${env2.ssh.host}`;
+  }
+  buildSSHParts(env2) {
+    const port = env2.ssh.port || 22;
+    let sshFlags = `-p ${port} -o ServerAliveInterval=30 -o StrictHostKeyChecking=no`;
+    let prefix = "";
+    if (env2.ssh.privateKeyPath) {
+      const keyPath = this.resolveVariables(env2.ssh.privateKeyPath);
+      sshFlags += ` -i ${keyPath}`;
+    } else if (env2.ssh.password) {
+      const password = this.resolveVariables(env2.ssh.password);
+      const escaped = password.replace(/'/g, "'\\''");
+      prefix = `sshpass -p '${escaped}' `;
+      sshFlags += ` -o PreferredAuthentications=password -o PubkeyAuthentication=no`;
+    }
+    return { prefix, sshFlags };
+  }
+  sshExec(env2, remoteCmd, opts) {
+    const { prefix, sshFlags } = this.buildSSHParts(env2);
+    const target = this.buildSSHConfig(env2);
+    const fullCmd = `${prefix}ssh ${sshFlags} ${target} "${remoteCmd.replace(/"/g, "\\\"")}"`;
+    if (!opts?.silent)
+      logger.debug(`SSH: ${remoteCmd}`);
+    try {
+      return execSync3(fullCmd, { encoding: "utf8", stdio: "pipe" }).trim();
+    } catch (error) {
+      const stderr = error.stderr?.toString() || "";
+      const msg = error.message || String(error);
+      if (msg.includes("sshpass: command not found") || msg.includes("sshpass: not found")) {
+        throw new Error(`sshpass is required for password authentication.
+` + `Install: brew install sshpass (macOS) / apt install sshpass (Linux)
+` + `Or use SSH key authentication instead.`);
+      }
+      throw new Error(`SSH command failed: ${remoteCmd}
+${stderr || msg}`);
+    }
+  }
+  scpUpload(env2, localPath, remotePath) {
+    const { prefix, sshFlags } = this.buildSSHParts(env2);
+    const target = this.buildSSHConfig(env2);
+    const port = env2.ssh.port || 22;
+    const scpFlags = sshFlags.replace(`-p ${port}`, "");
+    const fullCmd = `${prefix}scp -P ${port} ${scpFlags} "${localPath}" "${target}:${remotePath}"`;
+    logger.debug(`SCP upload: ${localPath} → ${remotePath}`);
+    try {
+      execSync3(fullCmd, { encoding: "utf8", stdio: "pipe" });
+    } catch (error) {
+      const stderr = error.stderr?.toString() || "";
+      throw new Error(`SCP upload failed: ${stderr || error.message}`);
+    }
+  }
+  async checkWordPressInstalled(env2) {
+    const webroot = this.deriveWebroot(env2);
+    logger.debug(`Checking WordPress at ${webroot}...`);
+    try {
+      const result2 = this.sshExec(env2, `test -f ${webroot}/wp-config.php && echo 'yes' || echo 'no'`, { silent: true });
+      return { installed: result2 === "yes", webroot };
+    } catch {
+      return { installed: false, webroot };
+    }
+  }
+  deriveWebroot(env2) {
+    const themePath = env2.remotePaths.theme;
+    const wpContentIdx = themePath.indexOf("/wp-content/");
+    if (wpContentIdx !== -1) {
+      return themePath.slice(0, wpContentIdx);
+    }
+    return path26.posix.resolve(themePath, "../../..");
+  }
+  askYesNo(question) {
+    return new Promise((resolve7) => {
+      const readline2 = __require("readline");
+      const rl = readline2.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      rl.question(`${question} (Y/n): `, (answer) => {
+        rl.close();
+        const n = answer.trim().toLowerCase();
+        resolve7(n === "" || n === "y" || n === "yes");
+      });
+    });
+  }
+  askInput(question, defaultValue) {
+    return new Promise((resolve7) => {
+      const readline2 = __require("readline");
+      const rl = readline2.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+      rl.question(prompt, (answer) => {
+        rl.close();
+        resolve7(answer.trim() || defaultValue || "");
+      });
+    });
+  }
+  async installWordPress(env2, webroot, sqlDump) {
+    logger.progress("Installing WordPress on remote server...");
+    logger.info("Checking for WP-CLI...");
+    try {
+      this.sshExec(env2, "wp --version", { silent: true });
+      logger.debug("WP-CLI already available");
+    } catch {
+      logger.info("Installing WP-CLI...");
+      this.sshExec(env2, `curl -O https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar && chmod +x wp-cli.phar && mkdir -p ~/bin && mv wp-cli.phar ~/bin/wp`);
+      logger.success("WP-CLI installed to ~/bin/wp");
+    }
+    const wp = "~/bin/wp";
+    this.sshExec(env2, `mkdir -p ${webroot}`);
+    logger.info("Downloading WordPress core...");
+    this.sshExec(env2, `${wp} core download --path=${webroot} --locale=pl_PL --skip-content`);
+    logger.success("WordPress core downloaded");
+    if (env2.database) {
+      const db = env2.database;
+      const dbHost = this.resolveVariables(db.host);
+      const dbPort = db.port || 3306;
+      const dbName = this.resolveVariables(db.database);
+      const dbUser = this.resolveVariables(db.username);
+      const dbPass = this.resolveVariables(db.password);
+      logger.info("Creating wp-config.php...");
+      this.sshExec(env2, `${wp} config create --path=${webroot} --dbname=${dbName} --dbuser=${dbUser} --dbpass='${dbPass.replace(/'/g, "'\\''")}' --dbhost=${dbHost}:${dbPort} --skip-check`);
+      logger.success("wp-config.php created");
+      if (sqlDump && fs23.existsSync(sqlDump)) {
+        logger.info(`Loading database dump from ${sqlDump}...`);
+        await this.loadDump(env2, sqlDump);
+        logger.success("Database imported from dump");
+      } else {
+        if (sqlDump) {
+          logger.warn(`Dump file not found at ${sqlDump}, falling back to fresh install`);
+        }
+        logger.info("Installing WordPress database...");
+        const siteUrl = env2.url || `https://${env2.ssh.host}`;
+        const adminUser = await this.askInput("Admin username", "admin");
+        const adminPassword = await this.askInput("Admin password");
+        const adminEmail = await this.askInput("Admin email");
+        const siteTitle = await this.askInput("Site title", env2.name);
+        this.sshExec(env2, `${wp} core install --path=${webroot} --url='${siteUrl}' --title='${siteTitle.replace(/'/g, "'\\''")}' --admin_user='${adminUser}' --admin_password='${adminPassword.replace(/'/g, "'\\''")}' --admin_email='${adminEmail}' --skip-email`);
+        logger.success("WordPress database installed");
+      }
+    } else {
+      logger.warn(`No database config in environment — skipping wp-config.php creation.
+` + "You'll need to create it manually on the server.");
+    }
+    this.sshExec(env2, `mkdir -p ${webroot}/wp-content/themes ${webroot}/wp-content/plugins`);
+    logger.success("WordPress installed on remote server");
+  }
+  async execute(options) {
+    const config = this.configManager.getConfig();
+    const environments = this.configManager.getEnvironments();
+    const env2 = environments.find((e) => e.name === options.environment);
+    if (!env2) {
+      throw new Error(`Environment "${options.environment}" not found in config. ` + `Available: ${environments.map((e) => e.name).join(", ")}`);
+    }
+    console.log("");
+    logger.progress(`Deploying to ${env2.name} (${env2.ssh.host})`);
+    console.log("");
+    try {
+      const { installed, webroot } = await this.checkWordPressInstalled(env2);
+      if (!installed) {
+        logger.warn(`WordPress not found at ${webroot}`);
+        const shouldInstall = await this.askYesNo("WordPress is not installed on the remote server. Install it now?");
+        if (shouldInstall) {
+          await this.installWordPress(env2, webroot, config.dev.sqlDump);
+        } else {
+          throw new Error(`WordPress is required on the remote server before deploying.
+` + "Install it manually or re-run deploy and choose to install.");
+        }
+      }
+      const hasDump = options.dump !== undefined;
+      let dumpPath;
+      if (hasDump) {
+        dumpPath = typeof options.dump === "string" ? options.dump : config.dev.sqlDump;
+        if (!dumpPath) {
+          throw new Error("No dump file specified. Use --dump <path> or set dev.sqlDump in config");
+        }
+      }
+      const steps = [];
+      if (!options.skipBuild)
+        steps.push("build");
+      steps.push("sync");
+      if (hasDump) {
+        steps.push("database");
+      } else if (env2.database) {
+        steps.push("content");
+      }
+      let step = 0;
+      const logStep = (msg) => {
+        step++;
+        logger.step(step, steps.length, msg);
+      };
+      if (!options.skipBuild) {
+        logStep("Building blocks and assets...");
+        const buildCommand = new BuildCommand;
+        await buildCommand.execute({ noCache: false });
+        logger.success("Build completed");
+      }
+      logStep("Syncing files to remote server...");
+      await this.syncFiles(env2, config.paths);
+      if (hasDump && dumpPath) {
+        logStep("Importing database...");
+        await this.loadDump(env2, dumpPath);
+      } else if (env2.database) {
+        logStep("Pushing content to remote database...");
+        await this.pushContent(env2);
+      }
+      console.log("");
+      logger.success(`\uD83D\uDE80 Deployment to ${env2.name} completed!`);
+      console.log("");
+    } catch (error) {
+      console.log("");
+      logger.error("Deployment failed:", error);
+      process.exit(1);
+    }
+  }
+  async syncFiles(env2, paths) {
+    const target = this.buildSSHConfig(env2);
+    try {
+      this.sshExec(env2, `mkdir -p ${env2.remotePaths.theme} ${env2.remotePaths.plugins}`, { silent: true });
+    } catch {}
+    logger.substep("theme");
+    this.rsync(paths.theme + "/", `${target}:${env2.remotePaths.theme}/`, env2);
+    logger.substep("plugins");
+    this.rsync(paths.plugins + "/", `${target}:${env2.remotePaths.plugins}/`, env2);
+    logger.success("Files synced");
+  }
+  rsync(source, destination, env2) {
+    const { prefix, sshFlags } = this.buildSSHParts(env2);
+    const rsyncCmd = `${prefix}rsync -avz --delete ` + `--exclude 'node_modules' --exclude '.git' --exclude '.DS_Store' --exclude '*.log' ` + `-e "ssh ${sshFlags}" ` + `"${source}" "${destination}"`;
+    try {
+      execSync3(rsyncCmd, { encoding: "utf8", stdio: "pipe" });
+    } catch (error) {
+      const msg = error.message || String(error);
+      const stderr = error.stderr?.toString() || "";
+      if (msg.includes("Disk quota exceeded") || stderr.includes("Disk quota exceeded")) {
+        throw new Error("Server disk quota exceeded. Free up space and retry.");
+      }
+      if (msg.includes("Permission denied") || stderr.includes("Permission denied")) {
+        throw new Error(`Permission denied writing to ${destination}.`);
+      }
+      if (msg.includes("Connection refused") || msg.includes("Connection timed out")) {
+        throw new Error(`Cannot connect to ${env2.ssh.host}.`);
+      }
+      if (msg.includes("sshpass: command not found") || msg.includes("sshpass: not found")) {
+        throw new Error("sshpass is required for password auth. Install: brew install sshpass");
+      }
+      if (msg.includes("child exited with status 11") || msg.includes("unexpected end of file")) {
+        throw new Error("Connection interrupted. Check disk quota and try again.");
+      }
+      throw new Error(`Rsync failed:
+${stderr || msg}`);
+    }
+  }
+  async pushContent(env2) {
+    if (!env2.database) {
+      throw new Error(`Database configuration not found for environment ${env2.name}`);
+    }
+    const tunnel = new SSHTunnel;
+    const closeTunnel = await tunnel.connect(env2.name);
+    try {
+      logger.substep("Pushing MDX content to remote database");
+      const pushCommand = new PushCommand;
+      const result2 = await pushCommand.execute({ force: true });
+      if (!result2.success) {
+        const errors = result2.errors.map((e) => e.error).join(", ");
+        throw new Error(`Failed to push content: ${errors}`);
+      }
+      logger.success(`Content pushed (${result2.filesProcessed} files)`);
+    } finally {
+      closeTunnel();
+    }
+  }
+  async loadDump(env2, dumpPath) {
+    if (!env2.database) {
+      throw new Error(`Database configuration not found for environment ${env2.name}`);
+    }
+    if (!fs23.existsSync(dumpPath)) {
+      throw new Error(`Dump file not found: ${dumpPath}`);
+    }
+    const db = env2.database;
+    const dbHost = this.resolveVariables(db.host);
+    const dbPort = db.port || 3306;
+    const dbName = this.resolveVariables(db.database);
+    const dbUser = this.resolveVariables(db.username);
+    const dbPass = this.resolveVariables(db.password);
+    logger.substep(`Uploading ${dumpPath}`);
+    const remoteDumpPath = `/tmp/wordpress-flow-dump-${Date.now()}.sql`;
+    this.scpUpload(env2, dumpPath, remoteDumpPath);
+    logger.substep("Importing into database");
+    const escapedPass = dbPass.replace(/'/g, "'\\''");
+    const mysqlCmd = `grep -v '^mysqldump:' ${remoteDumpPath} | mysql -h ${dbHost} -P ${dbPort} -u ${dbUser} -p'${escapedPass}' ${dbName} && rm ${remoteDumpPath}`;
+    this.sshExec(env2, mysqlCmd);
+    const webroot = this.deriveWebroot(env2);
+    const wp = "~/bin/wp";
+    if (env2.url) {
+      const config = this.configManager.getConfig();
+      const devPort = config.dev.port || 8888;
+      const oldUrl = `http://localhost:${devPort}`;
+      const newUrl = env2.url.replace(/\/$/, "");
+      logger.substep(`Rewriting URLs: ${oldUrl} → ${newUrl}`);
+      this.sshExec(env2, `${wp} search-replace '${oldUrl}' '${newUrl}' --path=${webroot} --all-tables --skip-columns=guid`);
+    } else {
+      logger.warn("No 'url' in environment config — skipping URL rewrite");
+    }
+    const themeSlug = path26.posix.basename(env2.remotePaths.theme);
+    logger.substep(`Activating theme: ${themeSlug}`);
+    try {
+      this.sshExec(env2, `${wp} theme activate ${themeSlug} --path=${webroot}`);
+    } catch {
+      logger.warn(`Could not activate theme "${themeSlug}"`);
+    }
+    logger.success("Database imported");
+  }
+}
+
 // src/index.ts
 var program2 = new Command;
 program2.name("wordpress-flow").description("Build WordPress sites with React, TypeScript, and MDX - A content-first development framework").version(package_default.version);
@@ -118045,7 +118589,7 @@ program2.command("setup").description("Run the configuration wizard").action(asy
     process.exit(1);
   }
 });
-program2.command("build").description("Build WordPress blocks for Gutenberg").option("--blocks-dir <dir>", "Source directory for blocks").option("--output-dir <dir>", "Output directory for built blocks").option("--webpack-config <path>", "Path to webpack config file").option("--watch", "Watch mode for development").option("-b, --blocks <names...>", "Specific block names to build").option("-c, --concurrency <number>", "Number of parallel workers (default: CPU cores - 1)").action(async (options) => {
+program2.command("build").description("Build WordPress blocks for Gutenberg").option("--blocks-dir <dir>", "Source directory for blocks").option("--output-dir <dir>", "Output directory for built blocks").option("--webpack-config <path>", "Path to webpack config file").option("--watch", "Watch mode for development").option("-b, --blocks <names...>", "Specific block names to build").option("-c, --concurrency <number>", "Number of parallel workers (default: CPU cores - 1)").option("--no-cache", "Disable cache and rebuild all blocks").action(async (options) => {
   try {
     await ensureConfiguration();
     const command = new BuildCommand;
@@ -118055,7 +118599,8 @@ program2.command("build").description("Build WordPress blocks for Gutenberg").op
       webpackConfig: options.webpackConfig,
       watch: options.watch || false,
       blocks: options.blocks,
-      concurrency: options.concurrency ? parseInt(options.concurrency, 10) : undefined
+      concurrency: options.concurrency ? parseInt(options.concurrency, 10) : undefined,
+      noCache: !options.cache
     });
     logger.info("Build command completed successfully");
   } catch (error) {
@@ -118066,9 +118611,14 @@ program2.command("build").description("Build WordPress blocks for Gutenberg").op
 program2.command("pull").description("Pull content from WordPress and convert to MDX").option("-f, --force", "Force overwrite existing files").option("--post-types <types...>", "Specific post types to pull").option("--post-ids <ids...>", "Specific post IDs to pull").option("--status <statuses...>", "Post statuses to include", [
   "publish",
   "draft"
-]).option("--output-dir <dir>", "Output directory for MDX files").action(async (options) => {
+]).option("--output-dir <dir>", "Output directory for MDX files").option("--env <environment>", "Pull from a remote environment via SSH tunnel").action(async (options) => {
+  let closeTunnel;
   try {
     await ensureConfiguration();
+    if (options.env) {
+      const tunnel = new SSHTunnel;
+      closeTunnel = await tunnel.connect(options.env);
+    }
     const command = new PullCommand;
     await command.execute({
       force: options.force || false,
@@ -118081,17 +118631,26 @@ program2.command("pull").description("Pull content from WordPress and convert to
   } catch (error) {
     logger.error("Pull command failed:", error);
     process.exit(1);
+  } finally {
+    closeTunnel?.();
   }
 });
-program2.command("push").description("Convert MDX files and push to WordPress").option("-f, --files <files...>", "Specific files to push").option("--force", "Force push, overriding conflicts").option("--dry-run", "Preview changes without pushing").action(async (options) => {
+program2.command("push").description("Convert MDX files and push to WordPress").option("-f, --files <files...>", "Specific files to push").option("--force", "Force push, overriding conflicts").option("--dry-run", "Preview changes without pushing").option("--env <environment>", "Push to a remote environment via SSH tunnel").action(async (options) => {
+  let closeTunnel;
   try {
     await ensureConfiguration();
+    if (options.env) {
+      const tunnel = new SSHTunnel;
+      closeTunnel = await tunnel.connect(options.env);
+    }
     const command = new PushCommand;
     await command.execute(options);
     logger.info("Push command completed successfully");
   } catch (error) {
     logger.error("Push command failed:", error);
     process.exit(1);
+  } finally {
+    closeTunnel?.();
   }
 });
 program2.command("build-templates").description("Build WordPress theme templates from MDX files").option("--templates-dir <dir>", "Source directory for template MDX files").option("--output-dir <dir>", "Output directory for HTML templates").action(async (options) => {
@@ -118137,6 +118696,20 @@ program2.command("destroy").description("Remove Docker containers and volumes fo
     process.exit(1);
   }
 });
+program2.command("deploy <environment>").description("Deploy to a remote environment (staging, production, etc.)").option("--skip-build", "Skip the build step").option("--dump [path]", "Load SQL dump instead of pushing MDX (uses config sqlDump if no path provided)").action(async (environment, options) => {
+  try {
+    await ensureConfiguration();
+    const command = new DeployCommand;
+    await command.execute({
+      environment,
+      skipBuild: options.skipBuild || false,
+      dump: options.dump
+    });
+  } catch (error) {
+    logger.error("Deploy command failed:", error);
+    process.exit(1);
+  }
+});
 var databaseCmd = program2.command("database").description("Database management commands");
 databaseCmd.command("import").description("Import SQL dump into Docker database").option("-f, --file <path>", "Path to SQL file (defaults to config sqlDump)").action(async (options) => {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wordpress-flow/cli",
-  "version": "1.2.12",
+  "version": "1.2.13",
   "type": "module",
   "description": "TypeScript-based WordPress block creation system",
   "main": "dist/index.js",