@amiable-dev/docusaurus-plugin-stentorosaur 0.17.0 → 0.18.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.18.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.18.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amiable-dev/docusaurus-plugin-stentorosaur",
-  "version": "0.17.0",
+  "version": "0.18.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",

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/src/plugin-status.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) Your Organization
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+declare module 'docusaurus-plugin-stentorosaur' {
+  export type StatusItemStatus = 'up' | 'down' | 'degraded' | 'maintenance';
+
+  export interface StatusItem {
+    name: string;
+    description?: string;
+    status: StatusItemStatus;
+    lastChecked?: string;
+    uptime?: string;
+    responseTime?: number;
+    incidentCount?: number;
+  }
+
+  export interface StatusIncident {
+    id: number;
+    title: string;
+    status: 'open' | 'closed';
+    severity: 'critical' | 'major' | 'minor' | 'maintenance';
+    createdAt: string;
+    updatedAt: string;
+    closedAt?: string;
+    url: string;
+    body?: string;
+    labels: string[];
+    affectedSystems: string[];
+  }
+
+  export interface PluginOptions {
+    /**
+     * GitHub repository owner (defaults to the site's organizationName)
+     */
+    owner?: string;
+    
+    /**
+     * GitHub repository name (defaults to the site's projectName)
+     */
+    repo?: string;
+    
+    /**
+     * Label to filter status issues (defaults to 'status')
+     */
+    statusLabel?: string;
+    
+    /**
+     * Labels that identify different systems/processes to track
+     */
+    systemLabels?: string[];
+    
+    /**
+     * GitHub personal access token for API requests
+     * Should be stored in environment variable
+     */
+    token?: string;
+    
+    /**
+     * How often to update status (in minutes, defaults to 60)
+     */
+    updateInterval?: number;
+    
+    /**
+     * Path where status data is stored (defaults to 'status-data')
+     */
+    dataPath?: string;
+
+    /**
+     * Title for the status page
+     */
+    title?: string;
+
+    /**
+     * Description for the status page
+     */
+    description?: string;
+
+    /**
+     * Whether to show response times
+     */
+    showResponseTimes?: boolean;
+
+    /**
+     * Whether to show uptime percentages
+     */
+    showUptime?: boolean;
+  }
+}
+
+declare module '@theme/StatusBoard' {
+  import type {StatusItem} from 'docusaurus-plugin-stentorosaur';
+  
+  export interface Props {
+    items: StatusItem[];
+    title?: string;
+    description?: string;
+  }
+  
+  export default function StatusBoard(props: Props): JSX.Element;
+}
+
+declare module '@theme/StatusItem' {
+  import type {StatusItem} from 'docusaurus-plugin-stentorosaur';
+  
+  export interface Props {
+    item: StatusItem;
+    showResponseTime?: boolean;
+    showUptime?: boolean;
+  }
+  
+  export default function StatusItem(props: Props): JSX.Element;
+}
+
+declare module '@theme/IncidentHistory' {
+  import type {StatusIncident} from 'docusaurus-plugin-stentorosaur';
+  
+  export interface Props {
+    incidents: StatusIncident[];
+    maxItems?: number;
+  }
+  
+  export default function IncidentHistory(props: Props): JSX.Element;
+}