plugship 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugship",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Deploy local WordPress plugins to remote sites from the command line",
   "type": "module",
   "bin": {
@@ -34,10 +34,10 @@
   ],
   "license": "MIT",
   "dependencies": {
+    "@inquirer/prompts": "^7.2.1",
     "archiver": "^7.0.1",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
-    "@inquirer/prompts": "^7.2.1",
     "form-data": "^4.0.1",
     "ora": "^8.1.1"
   }

package/src/commands/ignore.js

@@ -10,7 +10,7 @@ const DEFAULT_TEMPLATE = `# .plugshipignore
 #
 # The following are always excluded by default (no need to list them):
 #   node_modules, .git, .github, .DS_Store, .env, *.log,
-#   .vscode, .idea, tests, phpunit.xml, build
+#   .vscode, .idea, tests, phpunit.xml, builds
 
 # Source files (uncomment as needed)
 # src/**

package/src/commands/init.js

@@ -1,4 +1,4 @@
-import { input, password } from '@inquirer/prompts';
+import { input, password, confirm } from '@inquirer/prompts';
 import chalk from 'chalk';
 import { addSite } from '../lib/config.js';
 import { WordPressApi } from '../lib/wordpress-api.js';
@@ -13,87 +13,119 @@ export async function initCommand() {
     validate: (v) => (v.trim() ? true : 'Required'),
   });
 
-  const url = await input({
-    message: 'WordPress site URL:',
-    validate: (v) => {
-      if (!v.trim()) return 'Required';
-      try {
-        const parsed = new URL(v);
-        if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
-          return 'URL must start with https:// or http://';
+  let siteUrl, username, appPassword, api;
+  let connected = false;
+
+  // Loop until connection + auth succeed
+  while (!connected) {
+    siteUrl = await input({
+      message: 'WordPress site URL:',
+      validate: (v) => {
+        if (!v.trim()) return 'Required';
+        try {
+          const parsed = new URL(v);
+          if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+            return 'URL must start with https:// or http://';
+          }
+          return true;
+        } catch {
+          return 'Invalid URL';
         }
-        return true;
-      } catch {
-        return 'Invalid URL';
-      }
-    },
-  });
+      },
+    });
 
-  const username = await input({
-    message: 'WordPress username:',
-    validate: (v) => (v.trim() ? true : 'Required'),
-  });
+    siteUrl = siteUrl.replace(/\/+$/, '');
 
-  const appPassword = await password({
-    message: 'Application password:',
-    mask: '*',
-    validate: (v) => (v.trim() ? true : 'Required'),
-  });
+    // Test connection
+    const spin = logger.spinner('Testing connection to WordPress REST API...');
+    spin.start();
 
-  const siteUrl = url.replace(/\/+$/, '');
-  const api = new WordPressApi({ url: siteUrl, username, appPassword });
+    try {
+      const tempApi = new WordPressApi({ url: siteUrl, username: '', appPassword: '' });
+      await tempApi.testConnection();
+      spin.succeed('REST API is accessible');
+    } catch (err) {
+      spin.stop();
+      spin.clear();
+      logger.error('Cannot reach WordPress REST API');
+      logger.error(`Make sure ${siteUrl}/wp-json/ is accessible.\n  ${err.message}`);
+      console.log('');
+      const retry = await confirm({ message: 'Try a different URL?', default: true });
+      if (!retry) return;
+      continue;
+    }
 
-  // Test connection
-  const spin = logger.spinner('Testing connection to WordPress REST API...');
-  spin.start();
+    // Loop until auth succeeds or user quits
+    let authenticated = false;
+    while (!authenticated) {
+      username = await input({
+        message: 'WordPress username:',
+        validate: (v) => (v.trim() ? true : 'Required'),
+      });
 
-  try {
-    await api.testConnection();
-    spin.succeed('REST API is accessible');
-  } catch (err) {
-    spin.fail('Cannot reach WordPress REST API');
-    logger.error(`Make sure ${siteUrl}/wp-json/ is accessible.\n  ${err.message}`);
-    process.exitCode = 1;
-    return;
-  }
+      appPassword = await password({
+        message: 'Application password:',
+        mask: '*',
+        validate: (v) => (v.trim() ? true : 'Required'),
+      });
 
-  // Test authentication
-  spin.start('Verifying credentials...');
-  try {
-    const user = await api.testAuth();
-    const caps = user.capabilities || {};
-    if (!caps.install_plugins) {
-      spin.fail('User does not have the "install_plugins" capability');
-      logger.error('The user must be an Administrator to deploy plugins.');
-      process.exitCode = 1;
-      return;
+      api = new WordPressApi({ url: siteUrl, username, appPassword });
+
+      const spin2 = logger.spinner('Verifying credentials...');
+      spin2.start();
+      try {
+        const user = await api.testAuth();
+        const caps = user.capabilities || {};
+        if (!caps.install_plugins) {
+          spin2.stop();
+          spin2.clear();
+          logger.error('User does not have the "install_plugins" capability');
+          logger.error('The user must be an Administrator to deploy plugins.');
+          console.log('');
+          const retry = await confirm({ message: 'Try different credentials?', default: true });
+          if (!retry) return;
+          continue;
+        }
+        spin2.succeed(`Authenticated as "${user.name}"`);
+        authenticated = true;
+      } catch (err) {
+        spin2.stop();
+        spin2.clear();
+        logger.error(`Authentication failed`);
+        logger.error(`Check your username and application password.\n  ${err.message}`);
+        console.log('');
+        const retry = await confirm({ message: 'Try again?', default: true });
+        if (!retry) return;
+      }
     }
-    spin.succeed(`Authenticated as "${user.name}"`);
-  } catch (err) {
-    spin.fail('Authentication failed');
-    logger.error(`Check your username and application password.\n  ${err.message}`);
-    process.exitCode = 1;
-    return;
+
+    connected = true;
   }
 
   // Check receiver plugin
-  spin.start('Checking for plugship-receiver plugin...');
-  try {
-    const status = await api.checkReceiver();
-    spin.succeed(`Receiver plugin active (v${status.version})`);
-  } catch {
-    spin.warn('Receiver plugin not detected');
-    console.log('');
-    logger.warn(
-      'The plugship-receiver plugin must be installed and activated on your WordPress site.'
-    );
-    console.log(
-      chalk.dim(
-        `  1. Download: ${RECEIVER_DOWNLOAD_URL}\n` +
-        '  2. Upload and activate in WordPress admin (Plugins > Add New > Upload Plugin)\n' +
-        '  3. Run "plugship init" again to verify\n'
-      )
-    );
+  let receiverActive = false;
+  while (!receiverActive) {
+    const spin = logger.spinner('Checking for plugship-receiver plugin...');
+    spin.start();
+    try {
+      const status = await api.checkReceiver();
+      spin.succeed(`Receiver plugin active (v${status.version})`);
+      receiverActive = true;
+    } catch {
+      spin.warn('Receiver plugin not detected');
+      console.log('');
+      logger.warn(
+        'The plugship-receiver plugin must be installed and activated on your WordPress site.'
+      );
+      console.log(
+        chalk.dim(
+          `  1. Download: ${RECEIVER_DOWNLOAD_URL}\n` +
+          '  2. Upload and activate in WordPress admin (Plugins > Add New > Upload Plugin)\n'
+        )
+      );
+      const retry = await confirm({ message: 'Check again?', default: true });
+      if (!retry) break;
+    }
   }
 
   // Save config
@@ -103,5 +135,12 @@ export async function initCommand() {
     appPassword,
   });
 
-  logger.success(`Site "${name.trim()}" saved and set as default.\n`);
+  logger.success(`Site "${name.trim()}" saved and set as default.`);
+  console.log(chalk.bold('\nNext steps:\n'));
+  console.log(`  Navigate to your plugin directory and run:\n`);
+  console.log(chalk.cyan(`    plugship deploy\n`));
+  console.log(chalk.dim(`  Other useful commands:`));
+  console.log(chalk.dim(`    plugship deploy --dry-run       Preview without uploading`));
+  console.log(chalk.dim(`    plugship deploy --site ${name.trim()}   Deploy to this site`));
+  console.log(chalk.dim(`    plugship ignore                 Set up file exclusions\n`));
 }

package/src/lib/constants.js

@@ -27,5 +27,5 @@ export const DEFAULT_EXCLUDES = [
   '*.log',
   'tests/**',
   'phpunit.xml',
-  'build/**',
+  'builds/**',
 ];

package/src/lib/deployer.js

@@ -1,10 +1,10 @@
 import { join } from 'node:path';
-import { access } from 'node:fs/promises';
+import { access, stat } from 'node:fs/promises';
 import { select, confirm } from '@inquirer/prompts';
 import chalk from 'chalk';
 import { getSite, listSites } from './config.js';
 import { detectPlugin } from './plugin-detector.js';
-import { createPluginZip } from './zipper.js';
+import { createPluginZip, getIgnoreSource } from './zipper.js';
 import { WordPressApi } from './wordpress-api.js';
 import { DeployError, ConfigError } from './errors.js';
 import { RECEIVER_DOWNLOAD_URL } from './constants.js';
@@ -48,18 +48,19 @@ async function getAllSites() {
 }
 
 async function checkIgnoreFile(cwd) {
-  try {
-    await access(join(cwd, '.plugshipignore'));
-  } catch {
-    logger.warn('No .plugshipignore file found.');
-    const create = await confirm({
-      message: 'Create one with default template?',
-      default: true,
-    });
-    if (create) {
-      const { ignoreCommand } = await import('../commands/ignore.js');
-      await ignoreCommand([]);
-    }
+  const source = await getIgnoreSource(cwd);
+  if (source) {
+    logger.info(`Using ${source} for file exclusions`);
+    return;
+  }
+  logger.warn('No .plugshipignore or .distignore file found.');
+  const create = await confirm({
+    message: 'Create .plugshipignore with default template?',
+    default: true,
+  });
+  if (create) {
+    const { ignoreCommand } = await import('../commands/ignore.js');
+    await ignoreCommand([]);
   }
 }
 
@@ -83,12 +84,60 @@ export async function deploy({ siteName, activate = true, dryRun = false, all =
   // Detect plugin
   const plugin = await detectPlugin(cwd);
 
-  // Build ZIP once (shared across all targets)
-  const spin = logger.spinner('Creating ZIP archive...');
-  spin.start();
-  const { zipPath, size } = await createPluginZip(cwd, plugin.slug);
-  const sizeMB = (size / 1024 / 1024).toFixed(2);
-  spin.succeed(`ZIP created (${sizeMB} MB)`);
+  // Check for existing ZIP
+  const existingZipPath = join(cwd, 'builds', `${plugin.slug}.zip`);
+  let zipPath, size;
+
+  try {
+    const zipStat = await stat(existingZipPath);
+    const sizeMB = (zipStat.size / 1024 / 1024).toFixed(2);
+
+    // Check if ignore file was modified after the ZIP was built
+    let ignoreStale = false;
+    for (const ignoreFile of ['.plugshipignore', '.distignore']) {
+      try {
+        const ignoreStat = await stat(join(cwd, ignoreFile));
+        if (ignoreStat.mtimeMs > zipStat.mtimeMs) {
+          ignoreStale = true;
+        }
+        break;
+      } catch {
+        // file not found, try next
+      }
+    }
+
+    if (ignoreStale) {
+      logger.warn('Ignore file changed since last build — rebuilding ZIP...');
+      const spin = logger.spinner('Creating ZIP archive...');
+      spin.start();
+      ({ zipPath, size } = await createPluginZip(cwd, plugin.slug));
+      spin.succeed(`ZIP created (${(size / 1024 / 1024).toFixed(2)} MB)`);
+    } else {
+      logger.info(`Existing ZIP found: builds/${plugin.slug}.zip (${sizeMB} MB)`);
+      const action = await select({
+        message: 'What do you want to do?',
+        choices: [
+          { name: 'Use existing ZIP', value: 'existing' },
+          { name: 'Build a new ZIP', value: 'rebuild' },
+        ],
+      });
+      if (action === 'rebuild') {
+        const spin = logger.spinner('Creating ZIP archive...');
+        spin.start();
+        ({ zipPath, size } = await createPluginZip(cwd, plugin.slug));
+        spin.succeed(`ZIP created (${(size / 1024 / 1024).toFixed(2)} MB)`);
+      } else {
+        zipPath = existingZipPath;
+        size = zipStat.size;
+        logger.success(`Using existing ZIP (${sizeMB} MB)`);
+      }
+    }
+  } catch {
+    const spin = logger.spinner('Creating ZIP archive...');
+    spin.start();
+    ({ zipPath, size } = await createPluginZip(cwd, plugin.slug));
+    spin.succeed(`ZIP created (${(size / 1024 / 1024).toFixed(2)} MB)`);
+  }
 
   // Dry run — show summary and exit
   if (dryRun) {

package/src/lib/zipper.js

@@ -4,24 +4,51 @@ import { stat, mkdir, readFile } from 'node:fs/promises';
 import archiver from 'archiver';
 import { DEFAULT_EXCLUDES } from './constants.js';
 
+async function loadIgnoreFile(filePath) {
+  const content = await readFile(filePath, 'utf-8');
+  const patterns = [];
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith('#')) {
+      patterns.push(trimmed);
+    }
+  }
+  return patterns;
+}
+
+export async function getIgnoreSource(sourceDir) {
+  try {
+    await readFile(join(sourceDir, '.plugshipignore'), 'utf-8');
+    return '.plugshipignore';
+  } catch {
+    try {
+      await readFile(join(sourceDir, '.distignore'), 'utf-8');
+      return '.distignore';
+    } catch {
+      return null;
+    }
+  }
+}
+
 async function loadIgnorePatterns(sourceDir) {
   const patterns = [...DEFAULT_EXCLUDES];
-  try {
-    const content = await readFile(join(sourceDir, '.plugshipignore'), 'utf-8');
-    for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      if (trimmed && !trimmed.startsWith('#')) {
-        patterns.push(trimmed);
-      }
+
+  // .plugshipignore takes priority, then .distignore
+  for (const file of ['.plugshipignore', '.distignore']) {
+    try {
+      const extra = await loadIgnoreFile(join(sourceDir, file));
+      patterns.push(...extra);
+      return patterns;
+    } catch {
+      // file not found, try next
     }
-  } catch {
-    // No .plugshipignore file — use defaults only
   }
+
   return patterns;
 }
 
 export async function createPluginZip(sourceDir, slug) {
-  const buildDir = join(sourceDir, 'build');
+  const buildDir = join(sourceDir, 'builds');
   await mkdir(buildDir, { recursive: true });
   const zipName = `${slug}.zip`;
   const zipPath = join(buildDir, zipName);
@@ -52,11 +79,16 @@ export async function createPluginZip(sourceDir, slug) {
 }
 
 function matchGlob(filePath, pattern) {
-  // Strip trailing /** for directory matching
-  if (pattern.endsWith('/**')) {
-    const dir = pattern.slice(0, -3);
+  // Strip trailing /**, /* or / for directory matching
+  if (pattern.endsWith('/**') || pattern.endsWith('/*') || pattern.endsWith('/')) {
+    const dir = pattern.replace(/\/\*{0,2}$/, '');
     return filePath === dir || filePath.startsWith(dir + '/');
   }
+  // **/*.ext — match extension at any depth
+  if (pattern.startsWith('**/')) {
+    const sub = pattern.slice(3);
+    return matchGlob(filePath, sub) || filePath.split('/').some((seg) => matchGlob(seg, sub));
+  }
   // Exact match or wildcard prefix
   if (pattern.startsWith('*.')) {
     return filePath.endsWith(pattern.slice(1));
@@ -66,5 +98,10 @@ function matchGlob(filePath, pattern) {
     const firstSegment = filePath.split('/')[0];
     return firstSegment.startsWith('.');
   }
-  return filePath === pattern;
+  // Exact match (file or directory name)
+  // "resources" matches "resources", "resources/file.js", "resources/sub/file.js"
+  if (filePath === pattern || filePath.startsWith(pattern + '/')) {
+    return true;
+  }
+  return false;
 }