wpfleet 1.0.0

package/src/commands/update.js

@@ -0,0 +1,112 @@
+import chalk from 'chalk';
+import axios from 'axios';
+import { getSites, getSite } from '../config.js';
+import { makeTable } from '../utils/display.js';
+
+function makeClient(site) {
+  const baseURL = site.url.replace(/\/$/, '') + '/wp-json';
+  const config = { baseURL, timeout: 15000, validateStatus: () => true };
+  if (site.wp_user && site.wp_app_password) {
+    const token = Buffer.from(`${site.wp_user}:${site.wp_app_password}`).toString('base64');
+    config.headers = { Authorization: `Basic ${token}` };
+  }
+  return axios.create(config);
+}
+
+async function fetchPlugins(site) {
+  const client = makeClient(site);
+  const res = await client.get('/wp/v2/plugins', { params: { per_page: 100 } });
+  if (res.status === 401 || res.status === 403) {
+    return { error: 'Authentication required (wp_user + wp_app_password with admin role)' };
+  }
+  if (res.status !== 200 || !Array.isArray(res.data)) {
+    return { error: `HTTP ${res.status} — plugins endpoint unavailable` };
+  }
+  return { plugins: res.data };
+}
+
+async function applyUpdate(site, plugin) {
+  const client = makeClient(site);
+  // WP REST API supports updating plugin status but not version upgrades directly.
+  // This attempts the standard REST endpoint; actual upgrades require WP-CLI or admin.
+  const slug = plugin.plugin;
+  const res = await client.put(`/wp/v2/plugins/${encodeURIComponent(slug)}`, { status: plugin.status });
+  return res.status === 200;
+}
+
+export async function updateCommand(options) {
+  const siteName = options.site;
+  const applyUpdates = options.apply;
+
+  let sites;
+  if (options.all) {
+    sites = getSites();
+  } else if (siteName) {
+    const site = getSite(siteName);
+    if (!site) { console.error(chalk.red(`Site not found: ${siteName}`)); process.exit(1); }
+    sites = [site];
+  } else {
+    sites = getSites();
+  }
+
+  if (sites.length === 0) {
+    console.log(chalk.yellow('No sites configured. Run: wpfleet sites add'));
+    return;
+  }
+
+  for (const site of sites) {
+    console.log(chalk.bold(`\n=== ${site.name} ===`));
+
+    const result = await fetchPlugins(site);
+    if (result.error) {
+      console.log(chalk.yellow(`  Cannot fetch plugins: ${result.error}`));
+      continue;
+    }
+
+    const { plugins } = result;
+    const withUpdates = plugins.filter(p => p.update && p.update !== 'none' && p.update !== null);
+
+    if (plugins.length === 0) {
+      console.log(chalk.dim('  No plugins found'));
+      continue;
+    }
+
+    const table = makeTable(['Plugin', 'Version', 'Status', 'Update'], [32, 12, 12, 18]);
+    for (const p of plugins) {
+      const hasUpdate = p.update && p.update !== 'none';
+      const updateStr = hasUpdate
+        ? chalk.yellow(p.update?.version || 'available')
+        : chalk.green('up to date');
+      const statusStr = p.status === 'active' ? chalk.green('active') : chalk.gray(p.status || 'unknown');
+      table.push([
+        (p.name || p.plugin || '').slice(0, 30),
+        (p.version || 'n/a').slice(0, 10),
+        statusStr,
+        updateStr,
+      ]);
+    }
+    console.log(table.toString());
+
+    if (withUpdates.length === 0) {
+      console.log(chalk.green(`  All ${plugins.length} plugin(s) are up to date`));
+    } else {
+      console.log(chalk.yellow(`  ${withUpdates.length} plugin(s) have updates available`));
+    }
+
+    if (applyUpdates && withUpdates.length > 0) {
+      console.log(chalk.dim('\n  Attempting updates via REST API...'));
+      console.log(chalk.dim('  (Note: full plugin upgrades typically require WP-CLI or WP Admin)'));
+      for (const p of withUpdates) {
+        process.stdout.write(`  Updating ${p.name}... `);
+        try {
+          const ok = await applyUpdate(site, p);
+          console.log(ok ? chalk.green('done') : chalk.yellow('may need WP-CLI'));
+        } catch (err) {
+          console.log(chalk.red(`failed: ${err.message}`));
+        }
+      }
+    } else if (applyUpdates && withUpdates.length === 0) {
+      console.log(chalk.green('  Nothing to update'));
+    }
+  }
+}

package/src/config.js

@@ -0,0 +1,51 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import yaml from 'js-yaml';
+
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.wpfleet', 'config.yml');
+const LOCAL_CONFIG_PATH = path.join(process.cwd(), 'wpfleet.yml');
+
+export function getConfigPath() {
+  if (fs.existsSync(LOCAL_CONFIG_PATH)) return LOCAL_CONFIG_PATH;
+  return DEFAULT_CONFIG_PATH;
+}
+
+export function loadConfig() {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return { sites: [] };
+  }
+  try {
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const config = yaml.load(raw) || {};
+    if (!config.sites) config.sites = [];
+    return config;
+  } catch (err) {
+    console.error(`Error reading config at ${configPath}: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+export function saveConfig(config) {
+  const configPath = getConfigPath();
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  try {
+    fs.writeFileSync(configPath, yaml.dump(config), 'utf8');
+  } catch (err) {
+    console.error(`Error writing config at ${configPath}: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+export function getSite(name) {
+  const config = loadConfig();
+  return config.sites.find(s => s.name === name);
+}
+
+export function getSites() {
+  return loadConfig().sites;
+}

package/src/index.js

@@ -0,0 +1,231 @@
+import { Command } from 'commander';
+import { sitesList, sitesAdd, sitesRemove } from './commands/sites.js';
+import { statsCommand } from './commands/stats.js';
+import { healthCommand } from './commands/health.js';
+import { publishCommand, bulkPublishCommand } from './commands/publish.js';
+import { interlinkCommand, crosslinkCommand } from './commands/interlink.js';
+import { trafficCommand } from './commands/traffic.js';
+import { reportCommand } from './commands/report.js';
+import { updateCommand } from './commands/update.js';
+import { securityCommand } from './commands/security.js';
+import { aiWriteCommand } from './commands/ai-write.js';
+import { aiOptimizeCommand } from './commands/ai-optimize.js';
+
+const program = new Command();
+
+program
+  .name('wpfleet')
+  .description('Manage a network of WordPress blogs from the terminal')
+  .version('1.0.0');
+
+const sites = program.command('sites').description('Manage sites');
+
+sites
+  .command('list')
+  .description('List all configured sites with status')
+  .action(async () => {
+    try {
+      await sitesList();
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+sites
+  .command('add')
+  .description('Add a new site interactively')
+  .action(async () => {
+    try {
+      await sitesAdd();
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+sites
+  .command('remove <name>')
+  .description('Remove a site by name')
+  .action((name) => {
+    try {
+      sitesRemove(name);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('stats [site-name]')
+  .description('Show WordPress post/page stats for all or one site')
+  .action(async (siteName) => {
+    try {
+      await statsCommand(siteName);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('health [site-name]')
+  .description('Show health metrics for all or one site')
+  .action(async (siteName) => {
+    try {
+      await healthCommand(siteName);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('publish <file>')
+  .description('Publish a markdown file as a WordPress post')
+  .requiredOption('--site <name>', 'Target site name')
+  .option('--draft', 'Publish as draft instead of live')
+  .option('--schedule <datetime>', 'Schedule post (e.g. "2026-04-01 09:00")')
+  .action(async (file, options) => {
+    try {
+      await publishCommand(file, options);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('bulk-publish <directory>')
+  .description('Publish all .md files in a directory')
+  .option('--site <name>', 'Publish all files to this site')
+  .option('--distribute', 'Round-robin distribution across all configured sites')
+  .option('--dry-run', 'Show what would be published without doing it')
+  .option('--draft', 'Publish all as drafts')
+  .action(async (directory, options) => {
+    try {
+      await bulkPublishCommand(directory, options);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('interlink')
+  .description('Suggest internal links between posts on a site')
+  .option('--site <name>', 'Site to analyze (defaults to first site)')
+  .option('--auto', 'Automatically apply suggestions via WP REST API')
+  .option('--min-relevance <score>', 'Minimum relevance score 0-100 (default: 50)', '50')
+  .action(async (options) => {
+    try {
+      await interlinkCommand(options);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('crosslink <siteA> <siteB>')
+  .description('Find cross-linking opportunities between two sites')
+  .action(async (siteA, siteB) => {
+    try {
+      await crosslinkCommand(siteA, siteB);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('traffic')
+  .description('Show traffic data for sites (Jetpack/GA4)')
+  .option('--site <name>', 'Show traffic for one site')
+  .action(async (options) => {
+    try {
+      await trafficCommand(options);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('report')
+  .description('Generate a site report combining stats and health data')
+  .option('--site <name>', 'Generate report for one site')
+  .option('--month <YYYY-MM>', 'Report month (default: current)')
+  .option('--format <format>', 'Output format: md or html (default: md)', 'md')
+  .option('--output <file>', 'Save report to file (default: stdout)')
+  .action(async (options) => {
+    try {
+      await reportCommand(options);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('update')
+  .description('List and apply plugin updates via WP REST API')
+  .option('--site <name>', 'Check one site')
+  .option('--all', 'Check all sites')
+  .option('--apply', 'Apply available updates')
+  .action(async (options) => {
+    try {
+      await updateCommand(options);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('security')
+  .description('Run a security scan on sites (headers, SSL, WP hardening)')
+  .option('--site <name>', 'Scan one site')
+  .action(async (options) => {
+    try {
+      await securityCommand(options);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('ai-write')
+  .description('Generate an SEO-optimized article and publish it to a site')
+  .requiredOption('--topic <topic>', 'Article topic')
+  .requiredOption('--site <name>', 'Target site name')
+  .option('--lang <lang>', 'Language code (default: en)', 'en')
+  .option('--words <n>', 'Target word count (default: 1500)', '1500')
+  .option('--keywords <list>', 'Comma-separated keywords to target')
+  .option('--draft', 'Save as local .md file instead of publishing')
+  .action(async (options) => {
+    try {
+      await aiWriteCommand(options);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('ai-optimize')
+  .description('Analyze and optimize post SEO on a site')
+  .requiredOption('--site <name>', 'Site to analyze')
+  .option('--post <id>', 'Analyze a specific post by ID')
+  .option('--apply', 'Apply optimizations via WP API (requires --post)')
+  .action(async (options) => {
+    try {
+      await aiOptimizeCommand(options);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/src/utils/display.js

@@ -0,0 +1,41 @@
+import Table from 'cli-table3';
+import chalk from 'chalk';
+
+export function makeTable(head, colWidths) {
+  return new Table({
+    head: head.map(h => chalk.bold(h)),
+    colWidths,
+    style: { head: [], border: [] },
+  });
+}
+
+export function statusBadge(online) {
+  return online ? chalk.green('online') : chalk.red('offline');
+}
+
+export function colorByAge(days) {
+  if (days === null) return chalk.gray('n/a');
+  if (days <= 14) return chalk.red(`${days}d`);
+  if (days <= 30) return chalk.yellow(`${days}d`);
+  return chalk.green(`${days}d`);
+}
+
+export function colorByResponseTime(ms) {
+  if (ms === null) return chalk.gray('n/a');
+  if (ms > 2000) return chalk.red(`${ms}ms`);
+  if (ms > 800) return chalk.yellow(`${ms}ms`);
+  return chalk.green(`${ms}ms`);
+}
+
+export function formatDate(isoString) {
+  if (!isoString) return chalk.gray('n/a');
+  try {
+    return new Date(isoString).toISOString().slice(0, 10);
+  } catch {
+    return chalk.gray('n/a');
+  }
+}
+
+export function na() {
+  return chalk.gray('n/a');
+}

package/src/utils/http.js

@@ -0,0 +1,40 @@
+import https from 'https';
+import http from 'http';
+import axios from 'axios';
+
+export async function headCheck(url) {
+  const start = Date.now();
+  try {
+    await axios.head(url, { timeout: 8000, validateStatus: () => true });
+    return { online: true, responseTime: Date.now() - start };
+  } catch {
+    return { online: false, responseTime: null };
+  }
+}
+
+export async function getResponseTime(url) {
+  const start = Date.now();
+  try {
+    const res = await axios.get(url, { timeout: 10000, validateStatus: () => true });
+    return { ms: Date.now() - start, status: res.status };
+  } catch {
+    return { ms: null, status: null };
+  }
+}
+
+export function getSslExpiry(hostname) {
+  return new Promise((resolve) => {
+    const options = { host: hostname, port: 443, method: 'HEAD', rejectUnauthorized: false };
+    const req = https.request(options, (res) => {
+      const cert = res.socket.getPeerCertificate();
+      if (cert && cert.valid_to) {
+        resolve(new Date(cert.valid_to));
+      } else {
+        resolve(null);
+      }
+    });
+    req.on('error', () => resolve(null));
+    req.setTimeout(8000, () => { req.destroy(); resolve(null); });
+    req.end();
+  });
+}

package/src/utils/wp-api.js

@@ -0,0 +1,75 @@
+import axios from 'axios';
+
+function makeClient(site) {
+  const baseURL = site.url.replace(/\/$/, '') + '/wp-json';
+  const config = { baseURL, timeout: 12000, validateStatus: () => true };
+  if (site.wp_user && site.wp_app_password) {
+    const token = Buffer.from(`${site.wp_user}:${site.wp_app_password}`).toString('base64');
+    config.headers = { Authorization: `Basic ${token}` };
+  }
+  return axios.create(config);
+}
+
+export async function getWpInfo(site) {
+  const client = makeClient(site);
+  try {
+    const res = await client.get('/');
+    if (res.status !== 200) return null;
+    return res.data;
+  } catch {
+    return null;
+  }
+}
+
+export async function getPostCount(site) {
+  const client = makeClient(site);
+  try {
+    const res = await client.get('/wp/v2/posts', { params: { per_page: 1 } });
+    if (res.status !== 200) return null;
+    return parseInt(res.headers['x-wp-total'] || '0', 10);
+  } catch {
+    return null;
+  }
+}
+
+export async function getPageCount(site) {
+  const client = makeClient(site);
+  try {
+    const res = await client.get('/wp/v2/pages', { params: { per_page: 1 } });
+    if (res.status !== 200) return null;
+    return parseInt(res.headers['x-wp-total'] || '0', 10);
+  } catch {
+    return null;
+  }
+}
+
+export async function getLastPublished(site) {
+  const client = makeClient(site);
+  try {
+    const res = await client.get('/wp/v2/posts', { params: { per_page: 1, orderby: 'date', order: 'desc' } });
+    if (res.status !== 200 || !res.data || !res.data[0]) return null;
+    return res.data[0].date;
+  } catch {
+    return null;
+  }
+}
+
+export async function getPlugins(site) {
+  const client = makeClient(site);
+  try {
+    const res = await client.get('/wp/v2/plugins', { params: { per_page: 100 } });
+    if (res.status !== 200 || !Array.isArray(res.data)) return null;
+    return res.data;
+  } catch {
+    return null;
+  }
+}
+
+export async function validateWpApi(url) {
+  try {
+    const res = await axios.get(url.replace(/\/$/, '') + '/wp-json/', { timeout: 8000, validateStatus: () => true });
+    return res.status === 200 && res.data && res.data.name;
+  } catch {
+    return false;
+  }
+}