@amiable-dev/docusaurus-plugin-stentorosaur 0.17.0 → 0.19.0

package/lib/theme/StatusItem/MiniHeatmap.module.css

@@ -19,19 +19,19 @@
 .cells {
   display: flex;
   gap: 2px;
-  max-width: 100%;
+  width: 100%;
   margin-bottom: 0.75rem;
-  overflow-x: auto;
+  overflow: hidden;
 }
 
 .cell {
-  width: 3px;
-  height: 30px;
-  border-radius: 1px;
+  flex: 1;
+  min-width: 0;
+  height: 40px;
+  border-radius: 2px;
   cursor: pointer;
-  transition: transform 0.2s ease, opacity 0.2s ease;
+  transition: opacity 0.2s ease;
   position: relative;
-  flex-shrink: 0;
 }
 
 .cell.hasIncident {
@@ -74,9 +74,8 @@
 }
 
 .cell:hover {
-  transform: scale(1.3);
-  opacity: 0.8;
-  z-index: 1;
+  opacity: 0.7;
+  filter: brightness(1.1);
 }
 
 .legend {
@@ -135,8 +134,7 @@
   }
 
   .cell {
-    width: 2px;
-    height: 20px;
+    height: 30px;
   }
 
   .uptimeStats {

package/lib/version.d.ts

@@ -2,5 +2,5 @@
  * Plugin version - auto-generated during build
  * DO NOT EDIT MANUALLY - This file is generated from package.json
  */
-export declare const PLUGIN_VERSION = "0.17.0";
+export declare const PLUGIN_VERSION = "0.19.0";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -5,4 +5,4 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PLUGIN_VERSION = void 0;
-exports.PLUGIN_VERSION = '0.17.0';
+exports.PLUGIN_VERSION = '0.19.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amiable-dev/docusaurus-plugin-stentorosaur",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "A Docusaurus plugin for displaying status monitoring dashboard powered by GitHub Issues and Actions, similar to Upptime",
   "main": "lib/index.js",
   "types": "src/plugin-status.d.ts",
@@ -11,8 +11,16 @@
     "stentorosaur-setup-status-branch": "scripts/setup-status-branch.js",
     "stentorosaur-migrate-to-status-branch": "scripts/migrate-to-status-branch.js",
     "stentorosaur-cleanup-status-branch": "scripts/cleanup-status-branch.js",
-    "stentorosaur-bootstrap-summary": "scripts/bootstrap-summary.js"
+    "stentorosaur-bootstrap-summary": "scripts/bootstrap-summary.js",
+    "stentorosaur-init": "scripts/init.js",
+    "stentorosaur-config": "scripts/config.js"
   },
+  "files": [
+    "lib",
+    "scripts",
+    "templates",
+    "src/plugin-status.d.ts"
+  ],
   "keywords": [
     "docusaurus",
     "plugin",
@@ -37,6 +45,7 @@
     "watch": "tsc --build --watch",
     "dev": "tsc --build --watch",
     "prebuild": "node scripts/generate-version.js",
+    "postinstall": "node scripts/postinstall.js",
     "update-status": "node scripts/update-status.js",
     "setup-status-branch": "node scripts/setup-status-branch.js",
     "migrate-to-status-branch": "node scripts/migrate-to-status-branch.js",

package/scripts/config.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+
+/**
+ * Stentorosaur configuration management CLI
+ * Manages .monitorrc.json and docusaurus.config plugin options
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const CONFIG_FILE = '.monitorrc.json';
+const ENTITIES_FILE = '.stentorosaur-entities.json';
+
+// Parse command line arguments
+function parseArgs(args) {
+  const result = { command: args[0], options: {} };
+
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith('--')) {
+        result.options[key] = nextArg;
+        i++;
+      } else {
+        result.options[key] = true;
+      }
+    }
+  }
+
+  return result;
+}
+
+// Load monitor config
+async function loadConfig() {
+  const configPath = path.join(process.cwd(), CONFIG_FILE);
+
+  if (!await fs.pathExists(configPath)) {
+    return {
+      "$schema": "https://json-schema.org/draft-07/schema#",
+      "description": "Configuration file for status monitoring script",
+      "systems": []
+    };
+  }
+
+  return await fs.readJson(configPath);
+}
+
+// Save monitor config
+async function saveConfig(config) {
+  const configPath = path.join(process.cwd(), CONFIG_FILE);
+  await fs.writeJson(configPath, config, { spaces: 2 });
+}
+
+// Load entities config (for processes and additional metadata)
+async function loadEntities() {
+  const entitiesPath = path.join(process.cwd(), ENTITIES_FILE);
+
+  if (!await fs.pathExists(entitiesPath)) {
+    return { systems: [], processes: [] };
+  }
+
+  return await fs.readJson(entitiesPath);
+}
+
+// Save entities config
+async function saveEntities(entities) {
+  const entitiesPath = path.join(process.cwd(), ENTITIES_FILE);
+  await fs.writeJson(entitiesPath, entities, { spaces: 2 });
+}
+
+// Add a system to monitor
+async function addSystem(options) {
+  const name = options.name;
+  const url = options.url;
+  const method = options.method || 'GET';
+  const timeout = options.timeout || '10000';
+  const expectedCodes = options['expected-codes'] || '200';
+
+  if (!name || !url) {
+    console.error('\x1b[31mError:\x1b[0m Both --name and --url are required');
+    console.log('\nUsage: stentorosaur-config add-system --name api --url https://api.example.com/health');
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+
+  // Check if system already exists
+  const existingIndex = config.systems.findIndex(s => s.system === name);
+
+  const newSystem = {
+    system: name,
+    url: url,
+    method: method.toUpperCase(),
+    timeout: parseInt(timeout, 10),
+    expectedCodes: expectedCodes.split(',').map(c => parseInt(c.trim(), 10)),
+    maxResponseTime: 30000
+  };
+
+  if (existingIndex >= 0) {
+    config.systems[existingIndex] = newSystem;
+    console.log(`\x1b[33mUpdated:\x1b[0m System '${name}' configuration updated`);
+  } else {
+    config.systems.push(newSystem);
+    console.log(`\x1b[32mAdded:\x1b[0m System '${name}' added to ${CONFIG_FILE}`);
+  }
+
+  await saveConfig(config);
+
+  // Also add to entities for docusaurus config reference
+  const entities = await loadEntities();
+  if (!entities.systems.find(s => s.name === name)) {
+    entities.systems.push({ name, type: 'system', url });
+    await saveEntities(entities);
+  }
+
+  console.log(`\n  URL: ${url}`);
+  console.log(`  Method: ${method.toUpperCase()}`);
+  console.log(`  Timeout: ${timeout}ms`);
+  console.log(`  Expected codes: ${expectedCodes}`);
+}
+
+// Add a business process
+async function addProcess(options) {
+  const name = options.name;
+  const description = options.description || '';
+
+  if (!name) {
+    console.error('\x1b[31mError:\x1b[0m --name is required');
+    console.log('\nUsage: stentorosaur-config add-process --name deployments --description "Deployment pipeline"');
+    process.exit(1);
+  }
+
+  const entities = await loadEntities();
+
+  // Check if process already exists
+  const existingIndex = entities.processes.findIndex(p => p.name === name);
+
+  const newProcess = {
+    name,
+    type: 'process',
+    description: description || `${name} process tracking`
+  };
+
+  if (existingIndex >= 0) {
+    entities.processes[existingIndex] = newProcess;
+    console.log(`\x1b[33mUpdated:\x1b[0m Process '${name}' configuration updated`);
+  } else {
+    entities.processes.push(newProcess);
+    console.log(`\x1b[32mAdded:\x1b[0m Process '${name}' added to ${ENTITIES_FILE}`);
+  }
+
+  await saveEntities(entities);
+
+  console.log(`\n  Description: ${newProcess.description}`);
+  console.log(`\n\x1b[33mNote:\x1b[0m Add 'process:${name}' label to GitHub Issues to track this process.`);
+}
+
+// Remove a system
+async function removeSystem(options) {
+  const name = options.name;
+
+  if (!name) {
+    console.error('\x1b[31mError:\x1b[0m --name is required');
+    console.log('\nUsage: stentorosaur-config remove-system --name api');
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+  const originalLength = config.systems.length;
+  config.systems = config.systems.filter(s => s.system !== name);
+
+  if (config.systems.length === originalLength) {
+    console.log(`\x1b[33mWarning:\x1b[0m System '${name}' not found in ${CONFIG_FILE}`);
+  } else {
+    await saveConfig(config);
+    console.log(`\x1b[32mRemoved:\x1b[0m System '${name}' from ${CONFIG_FILE}`);
+  }
+
+  // Also remove from entities
+  const entities = await loadEntities();
+  entities.systems = entities.systems.filter(s => s.name !== name);
+  await saveEntities(entities);
+}
+
+// List all configured systems and processes
+async function list() {
+  const config = await loadConfig();
+  const entities = await loadEntities();
+
+  console.log('\n\x1b[32mMonitored Systems:\x1b[0m');
+  console.log('─'.repeat(60));
+
+  if (config.systems.length === 0) {
+    console.log('  No systems configured');
+    console.log('  Run: make status-add-system name=api url=https://...');
+  } else {
+    for (const system of config.systems) {
+      console.log(`\n  \x1b[36m${system.system}\x1b[0m`);
+      console.log(`    URL: ${system.url}`);
+      console.log(`    Method: ${system.method}`);
+      console.log(`    Timeout: ${system.timeout}ms`);
+      console.log(`    Expected: ${system.expectedCodes.join(', ')}`);
+    }
+  }
+
+  console.log('\n\n\x1b[32mBusiness Processes:\x1b[0m');
+  console.log('─'.repeat(60));
+
+  if (!entities.processes || entities.processes.length === 0) {
+    console.log('  No processes configured');
+    console.log('  Run: make status-add-process name=deployments');
+  } else {
+    for (const process of entities.processes) {
+      console.log(`\n  \x1b[36m${process.name}\x1b[0m`);
+      console.log(`    Label: process:${process.name}`);
+      if (process.description) {
+        console.log(`    Description: ${process.description}`);
+      }
+    }
+  }
+
+  console.log('\n');
+}
+
+// Validate configuration
+async function validate() {
+  const configPath = path.join(process.cwd(), CONFIG_FILE);
+
+  if (!await fs.pathExists(configPath)) {
+    console.error(`\x1b[31mError:\x1b[0m ${CONFIG_FILE} not found`);
+    console.log('Run: make status-init');
+    process.exit(1);
+  }
+
+  try {
+    const config = await fs.readJson(configPath);
+
+    const errors = [];
+    const warnings = [];
+
+    if (!config.systems || !Array.isArray(config.systems)) {
+      errors.push('Missing or invalid "systems" array');
+    } else {
+      for (let i = 0; i < config.systems.length; i++) {
+        const system = config.systems[i];
+
+        if (!system.system) {
+          errors.push(`System ${i + 1}: Missing "system" name`);
+        }
+        if (!system.url) {
+          errors.push(`System ${i + 1}: Missing "url"`);
+        } else {
+          try {
+            new URL(system.url);
+          } catch {
+            errors.push(`System ${i + 1}: Invalid URL "${system.url}"`);
+          }
+        }
+        if (system.timeout && (typeof system.timeout !== 'number' || system.timeout < 0)) {
+          warnings.push(`System ${i + 1}: Invalid timeout value`);
+        }
+      }
+    }
+
+    if (errors.length > 0) {
+      console.log('\x1b[31mValidation failed:\x1b[0m\n');
+      errors.forEach(e => console.log(`  - ${e}`));
+      process.exit(1);
+    }
+
+    if (warnings.length > 0) {
+      console.log('\x1b[33mWarnings:\x1b[0m\n');
+      warnings.forEach(w => console.log(`  - ${w}`));
+    }
+
+    console.log(`\x1b[32mConfiguration valid!\x1b[0m`);
+    console.log(`  ${config.systems.length} system(s) configured`);
+
+  } catch (err) {
+    console.error(`\x1b[31mError:\x1b[0m Failed to parse ${CONFIG_FILE}`);
+    console.error(err.message);
+    process.exit(1);
+  }
+}
+
+// Generate docusaurus config snippet
+async function generateConfig() {
+  const entities = await loadEntities();
+
+  const allEntities = [
+    ...entities.systems.map(s => ({ name: s.name, type: 'system' })),
+    ...entities.processes.map(p => ({ name: p.name, type: 'process' }))
+  ];
+
+  console.log('\n\x1b[32mDocusaurus Config Snippet:\x1b[0m');
+  console.log('─'.repeat(60));
+  console.log(`
+// Add to docusaurus.config.js plugins array:
+[
+  '@amiable-dev/docusaurus-plugin-stentorosaur',
+  {
+    owner: 'your-org',
+    repo: 'your-repo',
+    entities: ${JSON.stringify(allEntities, null, 6).replace(/\n/g, '\n    ')},
+  },
+],
+`);
+}
+
+// Main CLI
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.log('Stentorosaur Configuration Manager\n');
+    console.log('Commands:');
+    console.log('  add-system     Add a system to monitor');
+    console.log('  add-process    Add a business process');
+    console.log('  remove-system  Remove a system');
+    console.log('  list           List all configured systems and processes');
+    console.log('  validate       Validate configuration files');
+    console.log('  generate       Generate docusaurus.config.js snippet');
+    console.log('\nRun with --help for more info');
+    process.exit(0);
+  }
+
+  const { command, options } = parseArgs(args);
+
+  switch (command) {
+    case 'add-system':
+      await addSystem(options);
+      break;
+    case 'add-process':
+      await addProcess(options);
+      break;
+    case 'remove-system':
+      await removeSystem(options);
+      break;
+    case 'list':
+      await list();
+      break;
+    case 'validate':
+      await validate();
+      break;
+    case 'generate':
+      await generateConfig();
+      break;
+    default:
+      console.error(`\x1b[31mError:\x1b[0m Unknown command '${command}'`);
+      process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error('\x1b[31mError:\x1b[0m', err.message);
+  process.exit(1);
+});

package/scripts/init.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+/**
+ * Initialize Stentorosaur status monitoring in a consuming project
+ * Creates .monitorrc.json and status-data directory
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const CONFIG_FILE = '.monitorrc.json';
+const STATUS_DATA_DIR = 'status-data';
+
+const DEFAULT_CONFIG = {
+  "$schema": "https://json-schema.org/draft-07/schema#",
+  "description": "Configuration file for status monitoring script",
+  "systems": []
+};
+
+async function init() {
+  const cwd = process.cwd();
+  const configPath = path.join(cwd, CONFIG_FILE);
+  const statusDataPath = path.join(cwd, STATUS_DATA_DIR);
+
+  console.log('Initializing Stentorosaur status monitoring...\n');
+
+  // Create .monitorrc.json if it doesn't exist
+  if (await fs.pathExists(configPath)) {
+    console.log(`\x1b[33mWarning:\x1b[0m ${CONFIG_FILE} already exists. Skipping...`);
+  } else {
+    await fs.writeJson(configPath, DEFAULT_CONFIG, { spaces: 2 });
+    console.log(`\x1b[32mCreated:\x1b[0m ${CONFIG_FILE}`);
+  }
+
+  // Create status-data directory
+  await fs.ensureDir(statusDataPath);
+  console.log(`\x1b[32mCreated:\x1b[0m ${STATUS_DATA_DIR}/`);
+
+  // Create .gitkeep in status-data
+  const gitkeepPath = path.join(statusDataPath, '.gitkeep');
+  if (!await fs.pathExists(gitkeepPath)) {
+    await fs.writeFile(gitkeepPath, '');
+  }
+
+  console.log('\n\x1b[32mStatus monitoring initialized!\x1b[0m\n');
+  console.log('Next steps:');
+  console.log('  1. Add systems to monitor:');
+  console.log('     make status-add-system name=api url=https://api.example.com/health\n');
+  console.log('  2. Copy GitHub Actions workflows:');
+  console.log('     make status-workflows\n');
+  console.log('  3. Test your configuration:');
+  console.log('     make status-test\n');
+}
+
+init().catch(err => {
+  console.error('\x1b[31mError:\x1b[0m', err.message);
+  process.exit(1);
+});

package/scripts/postinstall.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for @amiable-dev/docusaurus-plugin-stentorosaur
+ * Automatically integrates status monitoring commands into the consuming project's Makefile
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Find the consuming project root (go up from node_modules)
+function findProjectRoot() {
+  let current = process.cwd();
+
+  // If we're in node_modules, go up to find project root
+  while (current.includes('node_modules')) {
+    current = path.dirname(current);
+  }
+
+  // Verify this looks like a project root
+  if (fs.existsSync(path.join(current, 'package.json'))) {
+    return current;
+  }
+
+  return null;
+}
+
+// Status monitoring section to add to help
+const STATUS_HELP_SECTION = `
+	@echo ""
+	@echo "$(GREEN)Status Monitoring:$(NC) (run 'make status-help' for full list)"
+	@echo "  $(YELLOW)status-add-system    $(NC) Add endpoint to monitor (name=x url=y)"
+	@echo "  $(YELLOW)status-list          $(NC) List all monitored systems"
+	@echo "  $(YELLOW)status-test          $(NC) Test monitoring configuration"
+	@echo "  $(YELLOW)status-help          $(NC) Show all status commands"`;
+
+// Include statement
+const INCLUDE_STATEMENT = '-include node_modules/@amiable-dev/docusaurus-plugin-stentorosaur/templates/Makefile.status';
+
+function patchMakefile(projectRoot) {
+  const makefilePath = path.join(projectRoot, 'Makefile');
+
+  if (!fs.existsSync(makefilePath)) {
+    console.log('[stentorosaur] No Makefile found - skipping integration');
+    console.log('[stentorosaur] Run "make status-help" after creating a Makefile with the include statement');
+    return false;
+  }
+
+  let content = fs.readFileSync(makefilePath, 'utf8');
+  let modified = false;
+
+  // Check if include statement already exists
+  if (!content.includes('docusaurus-plugin-stentorosaur/templates/Makefile.status')) {
+    // Add include at the end
+    content = content.trimEnd() + '\n\n# Status Monitoring (Stentorosaur)\n' + INCLUDE_STATEMENT + '\n';
+    modified = true;
+    console.log('[stentorosaur] Added Makefile.status include statement');
+  }
+
+  // Check if status help section exists in help target
+  if (content.includes('help:') && !content.includes('Status Monitoring:')) {
+    // Find the help target and add status section before the next target or end
+    // Look for pattern: help target ends with empty @echo "" line
+    const helpPattern = /(help:.*?@echo\s+["']["']\s*\n)(\n*#|\n*[a-zA-Z_-]+:|$)/s;
+    const match = content.match(helpPattern);
+
+    if (match) {
+      // Insert status help section after the last @echo "" in help target
+      const insertPoint = match.index + match[1].length;
+      content = content.slice(0, insertPoint) + STATUS_HELP_SECTION + '\n' + content.slice(insertPoint);
+      modified = true;
+      console.log('[stentorosaur] Added Status Monitoring section to make help');
+    }
+  }
+
+  if (modified) {
+    fs.writeFileSync(makefilePath, content);
+    console.log('[stentorosaur] Makefile updated successfully');
+    return true;
+  } else {
+    console.log('[stentorosaur] Makefile already configured');
+    return false;
+  }
+}
+
+function main() {
+  // Skip if running in CI or during npm publish
+  if (process.env.CI || process.env.npm_config_ignore_scripts) {
+    return;
+  }
+
+  const projectRoot = findProjectRoot();
+
+  if (!projectRoot) {
+    // Likely running during development of the plugin itself
+    return;
+  }
+
+  // Don't run if this is the plugin's own directory
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    if (pkg.name === '@amiable-dev/docusaurus-plugin-stentorosaur') {
+      return;
+    }
+  }
+
+  try {
+    patchMakefile(projectRoot);
+  } catch (err) {
+    console.error('[stentorosaur] Warning: Could not patch Makefile:', err.message);
+  }
+}
+
+main();