wpfleet 1.0.0

package/src/commands/publish.js

@@ -0,0 +1,136 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import axios from 'axios';
+import { marked } from 'marked';
+import matter from 'gray-matter';
+import { getSite, getSites } from '../config.js';
+import { makeTable } from '../utils/display.js';
+
+function makeClient(site) {
+  const baseURL = site.url.replace(/\/$/, '') + '/wp-json';
+  const token = Buffer.from(`${site.wp_user}:${site.wp_app_password}`).toString('base64');
+  return axios.create({
+    baseURL,
+    timeout: 15000,
+    validateStatus: () => true,
+    headers: { Authorization: `Basic ${token}` },
+  });
+}
+
+async function resolveTerms(client, taxonomy, names) {
+  const ids = [];
+  for (const name of names) {
+    const search = await client.get(`/wp/v2/${taxonomy}`, { params: { search: name, per_page: 10 } });
+    if (search.status === 200 && Array.isArray(search.data) && search.data.length > 0) {
+      const match = search.data.find(t => t.name.toLowerCase() === String(name).toLowerCase());
+      if (match) { ids.push(match.id); continue; }
+    }
+    const create = await client.post(`/wp/v2/${taxonomy}`, { name: String(name) });
+    if (create.status === 201) ids.push(create.data.id);
+  }
+  return ids;
+}
+
+async function publishPost(site, filePath, options) {
+  const raw = fs.readFileSync(filePath, 'utf8');
+  const { data: fm, content } = matter(raw);
+  const html = marked(content);
+
+  const title = fm.title || path.basename(filePath, '.md');
+  const excerpt = fm.excerpt || '';
+  let status = fm.status || 'publish';
+  if (options.draft) status = 'draft';
+
+  const payload = { title, content: html, status, excerpt };
+
+  if (options.schedule) {
+    payload.date = new Date(options.schedule).toISOString();
+    payload.status = 'future';
+  }
+
+  const client = makeClient(site);
+
+  const categories = Array.isArray(fm.categories) ? fm.categories : (fm.categories ? [fm.categories] : []);
+  const tags = Array.isArray(fm.tags) ? fm.tags : (fm.tags ? [fm.tags] : []);
+
+  if (categories.length > 0) payload.categories = await resolveTerms(client, 'categories', categories);
+  if (tags.length > 0) payload.tags = await resolveTerms(client, 'tags', tags);
+
+  const res = await client.post('/wp/v2/posts', payload);
+  if (res.status !== 201) {
+    throw new Error(`HTTP ${res.status}: ${JSON.stringify(res.data?.message || res.data)}`);
+  }
+  return res.data;
+}
+
+export async function publishCommand(filePath, options) {
+  if (!options.site) {
+    console.error(chalk.red('Error: --site <name> is required'));
+    process.exit(1);
+  }
+  const site = getSite(options.site);
+  if (!site) { console.error(chalk.red(`Site not found: ${options.site}`)); process.exit(1); }
+  if (!site.wp_user || !site.wp_app_password) {
+    console.error(chalk.red(`Site "${site.name}" requires wp_user and wp_app_password`));
+    process.exit(1);
+  }
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`File not found: ${filePath}`)); process.exit(1);
+  }
+
+  console.log(chalk.dim(`Publishing ${path.basename(filePath)} to ${site.name}...`));
+  const post = await publishPost(site, filePath, options);
+  console.log(chalk.green(`Published: ${post.link}`));
+}
+
+export async function bulkPublishCommand(directory, options) {
+  if (!fs.existsSync(directory)) {
+    console.error(chalk.red(`Directory not found: ${directory}`)); process.exit(1);
+  }
+
+  const files = fs.readdirSync(directory)
+    .filter(f => f.endsWith('.md'))
+    .map(f => path.join(directory, f));
+
+  if (files.length === 0) {
+    console.log(chalk.yellow('No .md files found in directory'));
+    return;
+  }
+
+  let sites = [];
+  if (options.distribute) {
+    sites = getSites();
+    if (sites.length === 0) { console.error(chalk.red('No sites configured')); process.exit(1); }
+  } else if (options.site) {
+    const site = getSite(options.site);
+    if (!site) { console.error(chalk.red(`Site not found: ${options.site}`)); process.exit(1); }
+    sites = [site];
+  } else {
+    console.error(chalk.red('Either --site <name> or --distribute is required'));
+    process.exit(1);
+  }
+
+  const table = makeTable(['File', 'Site', 'Status'], [30, 20, 30]);
+
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const site = sites[i % sites.length];
+    const fileName = path.basename(file);
+
+    if (options.dryRun) {
+      table.push([fileName, site.name, chalk.cyan('dry-run')]);
+      continue;
+    }
+
+    try {
+      const post = await publishPost(site, file, options);
+      table.push([fileName, site.name, chalk.green(`published`)]);
+      console.log(chalk.dim(`  ${fileName} → ${post.link}`));
+    } catch (err) {
+      table.push([fileName, site.name, chalk.red(`error: ${err.message}`.slice(0, 28))]);
+    }
+  }
+
+  console.log(table.toString());
+}

package/src/commands/report.js

@@ -0,0 +1,108 @@
+import fs from 'fs';
+import { URL } from 'url';
+import chalk from 'chalk';
+import { marked } from 'marked';
+import { getSites, getSite } from '../config.js';
+import { getPostCount, getPageCount, getLastPublished, getWpInfo, getPlugins } from '../utils/wp-api.js';
+import { getResponseTime, getSslExpiry } from '../utils/http.js';
+
+async function fetchSiteData(site) {
+  const { hostname } = new URL(site.url);
+  const [posts, pages, lastDate, wpInfo, timing, sslExpiry, plugins] = await Promise.all([
+    getPostCount(site),
+    getPageCount(site),
+    getLastPublished(site),
+    getWpInfo(site),
+    getResponseTime(site.url),
+    getSslExpiry(hostname),
+    getPlugins(site),
+  ]);
+
+  let wpVersion = null;
+  if (wpInfo && wpInfo.generator) {
+    const match = wpInfo.generator.match(/v=([\d.]+)/);
+    if (match) wpVersion = match[1];
+  }
+
+  let sslDays = null;
+  if (sslExpiry) {
+    sslDays = Math.floor((sslExpiry - Date.now()) / (1000 * 60 * 60 * 24));
+  }
+
+  const pluginCount = plugins ? plugins.length : null;
+  const pluginUpdates = plugins ? plugins.filter(p => p.update && p.update !== 'none').length : null;
+
+  return { posts, pages, lastDate, wpVersion, responseTime: timing.ms, sslDays, pluginCount, pluginUpdates };
+}
+
+function buildMarkdownReport(site, data, month) {
+  const lines = [];
+  const dateStr = month || new Date().toISOString().slice(0, 7);
+  lines.push(`# WP Fleet Report — ${site.name}`);
+  lines.push('');
+  lines.push(`**Month:** ${dateStr}  `);
+  lines.push(`**Generated:** ${new Date().toISOString().slice(0, 10)}  `);
+  lines.push(`**URL:** ${site.url}`);
+  lines.push('');
+  lines.push('## Site Overview');
+  lines.push('');
+  lines.push(`| Field | Value |`);
+  lines.push(`|-------|-------|`);
+  lines.push(`| WordPress Version | ${data.wpVersion || 'n/a'} |`);
+  lines.push(`| SSL Days Remaining | ${data.sslDays !== null ? data.sslDays + 'd' : 'n/a'} |`);
+  lines.push(`| Response Time | ${data.responseTime !== null ? data.responseTime + 'ms' : 'n/a'} |`);
+  lines.push('');
+  lines.push('## Content Stats');
+  lines.push('');
+  lines.push(`| Metric | Count |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Published Posts | ${data.posts ?? 'n/a'} |`);
+  lines.push(`| Pages | ${data.pages ?? 'n/a'} |`);
+  lines.push(`| Last Published | ${data.lastDate ? new Date(data.lastDate).toISOString().slice(0, 10) : 'n/a'} |`);
+  lines.push('');
+  lines.push('## Health Metrics');
+  lines.push('');
+  lines.push(`| Metric | Status |`);
+  lines.push(`|--------|--------|`);
+  lines.push(`| Plugins Installed | ${data.pluginCount ?? 'n/a'} |`);
+  lines.push(`| Plugins Needing Update | ${data.pluginUpdates ?? 'n/a'} |`);
+  lines.push('');
+  return lines.join('\n');
+}
+
+export async function reportCommand(options) {
+  const siteName = options.site;
+  const month = options.month;
+  const format = options.format || 'md';
+  const outputFile = options.output;
+
+  const sites = siteName
+    ? [getSite(siteName)].filter(Boolean)
+    : getSites();
+
+  if (sites.length === 0) {
+    console.log(chalk.yellow('No sites configured. Run: wpfleet sites add'));
+    return;
+  }
+
+  let fullReport = '';
+
+  for (const site of sites) {
+    if (!outputFile) console.log(chalk.dim(`Generating report for ${site.name}...`));
+    const data = await fetchSiteData(site);
+    const md = buildMarkdownReport(site, data, month);
+
+    if (format === 'html') {
+      fullReport += `<!DOCTYPE html><html><body>\n${marked(md)}\n</body></html>\n\n`;
+    } else {
+      fullReport += md + '\n---\n\n';
+    }
+  }
+
+  if (outputFile) {
+    fs.writeFileSync(outputFile, fullReport, 'utf8');
+    console.log(chalk.green(`Report saved to ${outputFile}`));
+  } else {
+    process.stdout.write(fullReport);
+  }
+}

package/src/commands/security.js

@@ -0,0 +1,158 @@
+import https from 'https';
+import { URL } from 'url';
+import chalk from 'chalk';
+import axios from 'axios';
+import { getSites, getSite } from '../config.js';
+
+async function checkHeaders(url) {
+  try {
+    const res = await axios.get(url, { timeout: 10000, validateStatus: () => true });
+    const h = res.headers;
+    return {
+      xFrameOptions: h['x-frame-options'] || null,
+      csp: h['content-security-policy'] || null,
+      hsts: h['strict-transport-security'] || null,
+      xContentType: h['x-content-type-options'] || null,
+      xXssProtection: h['x-xss-protection'] || null,
+    };
+  } catch {
+    return { xFrameOptions: null, csp: null, hsts: null, xContentType: null, xXssProtection: null };
+  }
+}
+
+async function checkSsl(siteUrl) {
+  const parsed = new URL(siteUrl);
+  if (parsed.protocol !== 'https:') return { ok: false, reason: 'Not HTTPS', days: null };
+
+  return new Promise((resolve) => {
+    const options = { host: parsed.hostname, port: 443, method: 'HEAD', rejectUnauthorized: false };
+    const req = https.request(options, (res) => {
+      const cert = res.socket.getPeerCertificate();
+      if (!cert || !cert.valid_to) { resolve({ ok: false, reason: 'No certificate', days: null }); return; }
+      const days = Math.floor((new Date(cert.valid_to) - Date.now()) / (1000 * 60 * 60 * 24));
+      resolve({ ok: res.socket.authorized !== false && days > 0, days, reason: null });
+    });
+    req.on('error', () => resolve({ ok: false, reason: 'Connection error', days: null }));
+    req.setTimeout(8000, () => { req.destroy(); resolve({ ok: false, reason: 'Timeout', days: null }); });
+    req.end();
+  });
+}
+
+async function checkExposedVersion(site) {
+  try {
+    const res = await axios.get(site.url.replace(/\/$/, '') + '/wp-json/', {
+      timeout: 8000, validateStatus: () => true,
+    });
+    if (res.status === 200 && res.data?.generator) {
+      const match = res.data.generator.match(/v=([\d.]+)/);
+      return match ? match[1] : null;
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+async function checkXmlRpc(siteUrl) {
+  try {
+    const res = await axios.post(siteUrl.replace(/\/$/, '') + '/xmlrpc.php',
+      '<?xml version="1.0"?><methodCall><methodName>demo.sayHello</methodName></methodCall>',
+      { timeout: 8000, validateStatus: () => true, headers: { 'Content-Type': 'text/xml' } }
+    );
+    return res.status === 200 && typeof res.data === 'string' && res.data.includes('methodResponse');
+  } catch {
+    return false;
+  }
+}
+
+async function checkDirectoryListing(siteUrl) {
+  try {
+    const res = await axios.get(siteUrl.replace(/\/$/, '') + '/wp-content/uploads/', {
+      timeout: 8000, validateStatus: () => true,
+    });
+    return res.status === 200 &&
+      typeof res.data === 'string' &&
+      res.data.toLowerCase().includes('index of');
+  } catch {
+    return false;
+  }
+}
+
+function row(ok, label, detail) {
+  const icon = ok ? chalk.green('✓') : chalk.red('✗');
+  const detailStr = detail ? chalk.dim(` (${detail})`) : '';
+  return `  ${icon} ${label}${detailStr}`;
+}
+
+function grade(pct) {
+  if (pct >= 90) return chalk.green('A');
+  if (pct >= 75) return chalk.green('B');
+  if (pct >= 60) return chalk.yellow('C');
+  if (pct >= 40) return chalk.yellow('D');
+  return chalk.red('F');
+}
+
+export async function securityCommand(options) {
+  const siteName = options.site;
+  const sites = siteName
+    ? [getSite(siteName)].filter(Boolean)
+    : 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} ===`));
+    console.log(chalk.dim(`Scanning ${site.url}...`));
+
+    const [headers, ssl, wpVersion, xmlRpc, dirListing] = await Promise.all([
+      checkHeaders(site.url),
+      checkSsl(site.url),
+      checkExposedVersion(site),
+      checkXmlRpc(site.url),
+      checkDirectoryListing(site.url),
+    ]);
+
+    let score = 0;
+
+    // SSL (20 pts)
+    console.log(chalk.bold('\nSSL:'));
+    if (ssl.ok) {
+      const daysColor = ssl.days > 30 ? chalk.green : ssl.days > 14 ? chalk.yellow : chalk.red;
+      console.log(row(true, 'SSL valid', `${daysColor(ssl.days + 'd')} remaining`));
+      score += ssl.days > 30 ? 20 : ssl.days > 14 ? 15 : 10;
+    } else {
+      console.log(row(false, 'SSL invalid or missing', ssl.reason));
+    }
+
+    // Security Headers (40 pts)
+    console.log(chalk.bold('\nSecurity Headers:'));
+    const xfo = !!headers.xFrameOptions;
+    const csp = !!headers.csp;
+    const hsts = !!headers.hsts;
+    const xct = !!headers.xContentType;
+    console.log(row(xfo, 'X-Frame-Options', xfo ? headers.xFrameOptions : null));
+    console.log(row(csp, 'Content-Security-Policy', csp ? 'present' : null));
+    console.log(row(hsts, 'Strict-Transport-Security (HSTS)', hsts ? 'present' : null));
+    console.log(row(xct, 'X-Content-Type-Options', xct ? headers.xContentType : null));
+    if (xfo) score += 10;
+    if (csp) score += 15;
+    if (hsts) score += 10;
+    if (xct) score += 5;
+
+    // WordPress hardening (40 pts)
+    console.log(chalk.bold('\nWordPress Hardening:'));
+    const versionHidden = !wpVersion;
+    const xmlRpcDisabled = !xmlRpc;
+    const dirDisabled = !dirListing;
+    console.log(row(versionHidden, 'WP version hidden', wpVersion ? `exposed: ${wpVersion}` : null));
+    console.log(row(xmlRpcDisabled, 'XML-RPC disabled', xmlRpc ? 'enabled — potential attack surface' : null));
+    console.log(row(dirDisabled, 'Directory listing disabled', dirListing ? 'enabled!' : null));
+    if (versionHidden) score += 10;
+    if (xmlRpcDisabled) score += 15;
+    if (dirDisabled) score += 15;
+
+    const pct = score;
+    console.log(chalk.bold(`\nSecurity Score: ${grade(pct)} ${chalk.dim(`(${pct}/100)`)}`));
+  }
+}

package/src/commands/sites.js

@@ -0,0 +1,98 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { loadConfig, saveConfig, getSites } from '../config.js';
+import { headCheck } from '../utils/http.js';
+import { validateWpApi } from '../utils/wp-api.js';
+import { makeTable, statusBadge } from '../utils/display.js';
+
+export async function sitesList() {
+  const sites = getSites();
+  if (sites.length === 0) {
+    console.log(chalk.yellow('No sites configured. Run: wpfleet sites add'));
+    return;
+  }
+
+  console.log(chalk.dim('Checking site status...'));
+  const table = makeTable(['Name', 'URL', 'Status'], [20, 40, 12]);
+
+  const checks = await Promise.all(sites.map(s => headCheck(s.url)));
+  for (let i = 0; i < sites.length; i++) {
+    const s = sites[i];
+    const { online } = checks[i];
+    table.push([s.name, s.url, statusBadge(online)]);
+  }
+  console.log(table.toString());
+}
+
+export async function sitesAdd() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Site name (slug):',
+      validate: v => v.trim() ? true : 'Name is required',
+    },
+    {
+      type: 'input',
+      name: 'url',
+      message: 'Site URL (https://example.com):',
+      validate: v => v.startsWith('http') ? true : 'URL must start with http',
+    },
+    {
+      type: 'input',
+      name: 'wp_user',
+      message: 'WordPress username:',
+    },
+    {
+      type: 'password',
+      name: 'wp_app_password',
+      message: 'WordPress application password:',
+      mask: '*',
+    },
+    {
+      type: 'input',
+      name: 'ga4_property',
+      message: 'GA4 property ID (optional, e.g. properties/123456789):',
+    },
+  ]);
+
+  const url = answers.url.replace(/\/$/, '');
+  process.stdout.write(chalk.dim('Validating WordPress REST API... '));
+  const valid = await validateWpApi(url);
+  if (!valid) {
+    console.log(chalk.red('failed'));
+    console.log(chalk.yellow('Warning: WordPress REST API not accessible. Site added anyway.'));
+  } else {
+    console.log(chalk.green('OK'));
+  }
+
+  const config = loadConfig();
+  const existing = config.sites.findIndex(s => s.name === answers.name);
+
+  const site = { name: answers.name.trim(), url };
+  if (answers.wp_user) site.wp_user = answers.wp_user;
+  if (answers.wp_app_password) site.wp_app_password = answers.wp_app_password;
+  if (answers.ga4_property) site.ga4_property = answers.ga4_property;
+
+  if (existing >= 0) {
+    config.sites[existing] = site;
+    console.log(chalk.green(`Updated site: ${site.name}`));
+  } else {
+    config.sites.push(site);
+    console.log(chalk.green(`Added site: ${site.name}`));
+  }
+
+  saveConfig(config);
+}
+
+export function sitesRemove(name) {
+  const config = loadConfig();
+  const before = config.sites.length;
+  config.sites = config.sites.filter(s => s.name !== name);
+  if (config.sites.length === before) {
+    console.error(chalk.red(`Site not found: ${name}`));
+    process.exit(1);
+  }
+  saveConfig(config);
+  console.log(chalk.green(`Removed site: ${name}`));
+}

package/src/commands/stats.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { getSites, getSite } from '../config.js';
+import { getPostCount, getPageCount, getLastPublished } from '../utils/wp-api.js';
+import { makeTable, formatDate, na } from '../utils/display.js';
+
+async function fetchStats(site) {
+  const [posts, pages, lastDate] = await Promise.all([
+    getPostCount(site),
+    getPageCount(site),
+    getLastPublished(site),
+  ]);
+  return { posts, pages, lastDate };
+}
+
+function renderRow(site, stats) {
+  const posts = stats.posts !== null ? String(stats.posts) : na();
+  const pages = stats.pages !== null ? String(stats.pages) : na();
+  const last = formatDate(stats.lastDate);
+  return [site.name, site.url, posts, pages, last];
+}
+
+export async function statsCommand(siteName) {
+  const table = makeTable(['Name', 'URL', 'Posts', 'Pages', 'Last Published'], [18, 36, 8, 8, 14]);
+
+  if (siteName) {
+    const site = getSite(siteName);
+    if (!site) {
+      console.error(chalk.red(`Site not found: ${siteName}`));
+      process.exit(1);
+    }
+    console.log(chalk.dim(`Fetching stats for ${site.name}...`));
+    const stats = await fetchStats(site);
+    table.push(renderRow(site, stats));
+  } else {
+    const sites = getSites();
+    if (sites.length === 0) {
+      console.log(chalk.yellow('No sites configured. Run: wpfleet sites add'));
+      return;
+    }
+    console.log(chalk.dim('Fetching stats for all sites...'));
+    const allStats = await Promise.all(sites.map(fetchStats));
+    for (let i = 0; i < sites.length; i++) {
+      table.push(renderRow(sites[i], allStats[i]));
+    }
+  }
+
+  console.log(table.toString());
+}

package/src/commands/traffic.js

@@ -0,0 +1,87 @@
+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: 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);
+}
+
+async function fetchJetpackStats(site) {
+  const client = makeClient(site);
+  try {
+    const res = await client.get('/jetpack/v4/stats/visitors');
+    if (res.status === 200 && res.data && typeof res.data === 'object') return res.data;
+  } catch { /* not available */ }
+  return null;
+}
+
+async function fetchWpComStats(site) {
+  const client = makeClient(site);
+  try {
+    const res = await client.get('/wpcom/v2/stats/visits');
+    if (res.status === 200 && res.data) return res.data;
+  } catch { /* not available */ }
+  return null;
+}
+
+export async function trafficCommand(options) {
+  const siteName = options.site;
+  const sites = siteName
+    ? [getSite(siteName)].filter(Boolean)
+    : 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} ===`));
+    console.log(chalk.dim(site.url));
+
+    if (site.ga4_property) {
+      console.log(chalk.cyan(`GA4 property configured: ${site.ga4_property}`));
+      console.log(chalk.dim('Full GA4 traffic data requires additional auth setup:'));
+      console.log(chalk.dim('  1. Create a service account in Google Cloud Console'));
+      console.log(chalk.dim('  2. Grant it "Viewer" access to your GA4 property'));
+      console.log(chalk.dim('  3. Set GOOGLE_APPLICATION_CREDENTIALS env var'));
+    }
+
+    // Try Jetpack stats
+    const jetpack = await fetchJetpackStats(site);
+    if (jetpack) {
+      console.log(chalk.green('\nJetpack Stats:'));
+      const table = makeTable(['Metric', 'Value'], [25, 20]);
+      if (jetpack.visitors !== undefined) table.push(['Visitors', String(jetpack.visitors)]);
+      if (jetpack.views !== undefined) table.push(['Views', String(jetpack.views)]);
+      if (jetpack.period !== undefined) table.push(['Period', String(jetpack.period)]);
+      console.log(table.toString());
+      continue;
+    }
+
+    // Try WP.com stats
+    const wpcom = await fetchWpComStats(site);
+    if (wpcom) {
+      console.log(chalk.green('\nWP.com Stats:'));
+      const table = makeTable(['Metric', 'Value'], [25, 20]);
+      if (wpcom.views !== undefined) table.push(['Views', String(wpcom.views)]);
+      if (wpcom.visitors !== undefined) table.push(['Visitors', String(wpcom.visitors)]);
+      console.log(table.toString());
+      continue;
+    }
+
+    // No traffic source available
+    console.log(chalk.dim('\nNo traffic data available for this site.'));
+    const table = makeTable(['Option', 'How to enable'], [20, 50]);
+    table.push(['GA4', 'Add ga4_property to site config + set up Google auth']);
+    table.push(['Jetpack', 'Install Jetpack plugin + connect to WordPress.com']);
+    console.log(table.toString());
+  }
+}