gpxe 1.0.0

package/src/commands/deploy.js

@@ -0,0 +1,36 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const { resolveEndpoint, request } = require('../api');
+const { printRequestError } = require('../util');
+const { isDemo } = require('../demo');
+
+const deployCommand = program.command('deploy').description('Deployment helpers.');
+
+deployCommand
+    .command('rollback <version>')
+    .description('Request a rollback of a deploy.')
+    .option('--service <name>', 'Filter to a specific service')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .option('--demo', 'Use demo data')
+    .action(async (version, opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const payload = { version, service: opts.service || null };
+    try {
+        const data = isDemo(opts)
+            ? { status: 'queued', ...payload }
+            : (await request('post', endpoint, '/deploy/rollback', payload)).data || payload;
+        if (opts.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        console.log(chalk.cyan('Rollback request'));
+        console.log(`Version: ${version}`);
+        if (payload.service) {
+            console.log(`Service: ${payload.service}`);
+        }
+        console.log(`Status: ${data.status || 'queued'}`);
+    } catch (e) {
+        printRequestError(e, 'Failed to request rollback.', endpoint);
+    }
+});

package/src/commands/incidents.js

@@ -0,0 +1,144 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const { resolveEndpoint, request } = require('../api');
+const { toInt, printRequestError, shouldShowHints, wantsJSON } = require('../util');
+const { isDemo, demoIncidentExplain } = require('../demo');
+
+program.command('incident <title>')
+    .description('Declare an incident update.')
+    .option('--status <type>', 'critical, degraded', 'critical')
+    .option('--severity <level>', 'low, medium, high, critical', 'high')
+    .option('--service <name>', 'Service name')
+    .option('--summary <text>', 'Short summary for operators')
+    .option('--endpoint <url>', 'Override endpoint')
+    .action(async (title, opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    try {
+        const payload = {
+            title,
+            status: opts.status,
+            severity: opts.severity,
+            service: opts.service,
+            summary: opts.summary
+        };
+        const response = await request('post', endpoint, '/incidents', payload);
+        const incident = response.data?.incident || null;
+        console.log(chalk.red.bold(`\n🚨 INCIDENT DECLARED: ${title}`));
+        if (incident?.id) {
+            console.log(chalk.white(`Incident ID: ${incident.id}`));
+        }
+        console.log(chalk.white('Public status page updated immediately.'));
+        if (incident?.id && shouldShowHints()) {
+            console.log(chalk.gray(`Tip: gpxe incidents explain ${incident.id}`));
+        }
+    } catch (e) {
+        printRequestError(e, 'Failed to report incident.', endpoint);
+    }
+});
+
+const incidentsCommand = program.command('incidents')
+    .description('Fetch the latest incident details.')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    try {
+        const response = await request('get', endpoint, '/incidents');
+        const incident = response.data || null;
+        if (opts.json) {
+            console.log(JSON.stringify({ endpoint, incident }, null, 2));
+            return;
+        }
+        if (!incident) {
+            console.log(chalk.green('No incidents reported.'));
+            return;
+        }
+        console.log(chalk.red(`Latest incident: ${incident.title || 'Untitled'}`));
+        console.log(`Status: ${incident.status || 'unknown'}`);
+        if (incident.severity) {
+            console.log(`Severity: ${incident.severity}`);
+        }
+        if (incident.service) {
+            console.log(`Service: ${incident.service}`);
+        }
+        console.log(`Created: ${incident.created_at || 'unknown'}`);
+    } catch (e) {
+        printRequestError(e, 'Failed to fetch incidents.', endpoint);
+    }
+});
+
+incidentsCommand
+    .command('explain <incident_id>')
+    .description('Explain the likely causes behind an incident.')
+    .option('--service <name>', 'Filter to a specific service')
+    .option('--since <window>', 'Lookback window (e.g. 24h)')
+    .option('--evidence <count>', 'Number of evidence items', '5')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .option('--demo', 'Use demo data')
+    .option('--quiet', 'Suppress suggested actions')
+    .action(async (incidentId, opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const params = {};
+    if (opts.service) params.service = opts.service;
+    if (opts.since) params.since = opts.since;
+    if (opts.evidence) params.evidence = toInt(opts.evidence, 5);
+    if (opts.quiet) params.quiet = true;
+    try {
+        const data = isDemo(opts)
+            ? demoIncidentExplain(incidentId)
+            : (await request('get', endpoint, `/incidents/${encodeURIComponent(incidentId)}/explain`, null, params))
+                  .data || {};
+        if (opts.json || wantsJSON()) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const incidentLabel = data.id || incidentId;
+        const severity = data.severity || 'unknown';
+        const status = data.status || 'unknown';
+        const summary = data.summary || 'No summary available.';
+        const confidence = Number.isFinite(data.confidence) ? data.confidence : null;
+        console.log(chalk.cyan(`Incident: ${incidentLabel}  (Severity: ${severity})  Status: ${status}`));
+        console.log(`Summary: ${summary}`);
+        console.log(`Confidence: ${confidence !== null ? confidence : 'n/a'}`);
+        console.log('');
+        if (data.primary_cause) {
+            const cause = data.primary_cause;
+            const causeLabel = [cause.type, cause.id].filter(Boolean).join(':') || 'unknown';
+            const score = Number.isFinite(cause.score) ? cause.score : 'n/a';
+            console.log('Primary cause:');
+            console.log(`- ${causeLabel} (change score ${score})`);
+        } else {
+            console.log('Primary cause: not available.');
+        }
+        if (Array.isArray(data.signals) && data.signals.length > 0) {
+            console.log('');
+            console.log('Contributing signals:');
+            data.signals.forEach((signal) => {
+                const name = signal.name || signal.metric || 'signal';
+                const delta = signal.delta ?? signal.change ?? 'n/a';
+                const service = signal.service ? ` (service/${signal.service})` : '';
+                console.log(`- ${name} ${delta}${service}`);
+            });
+        }
+        if (Array.isArray(data.evidence) && data.evidence.length > 0) {
+            console.log('');
+            console.log(`Evidence (top ${data.evidence.length}):`);
+            data.evidence.forEach((item, index) => {
+                const detail = item.detail || item.kind || 'evidence';
+                console.log(`${index + 1}) ${detail}`);
+            });
+        }
+        if (!opts.quiet && Array.isArray(data.suggested_actions) && data.suggested_actions.length > 0) {
+            console.log('');
+            console.log('Suggested actions:');
+            data.suggested_actions.forEach((action) => {
+                const cmd = action.cmd ? ` (${action.cmd})` : '';
+                const reason = action.reason || 'Follow up';
+                console.log(`- ${reason}${cmd}`);
+            });
+        }
+    } catch (e) {
+        printRequestError(e, 'Failed to explain incident.', endpoint);
+    }
+});

package/src/commands/reserve.js

@@ -0,0 +1,17 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const crypto = require('crypto');
+
+program
+    .command('reserve')
+    .description('Reserve a spot in the private beta.')
+    .action(async () => {
+        // Generate a cryptographically strong random token
+        const randomBytes = crypto.randomBytes(4).toString('hex').toUpperCase(); // 8 chars
+        const token = `GP-${randomBytes.slice(0, 4)}-${randomBytes.slice(4)}`;
+
+        console.log(chalk.bold('\n⚡ Gridpoint Analytics Private Beta Reservation ⚡\n'));
+        console.log('Use this token to claim your spot on the waitlist:');
+        console.log('\n' + chalk.bgBlue.white.bold(`  ${token}  `) + '\n');
+        console.log(chalk.gray('Enter this token at https://gridpointanalytics.com\n'));
+    });

package/src/commands/runbooks.js

@@ -0,0 +1,51 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const { resolveEndpoint, request } = require('../api');
+const { printRequestError, shouldShowHints } = require('../util');
+const { isDemo, demoRunbookSuggest } = require('../demo');
+
+const runbooksCommand = program.command('runbooks').description('Runbook intelligence commands.');
+
+runbooksCommand
+    .command('suggest <incident_id>')
+    .description('Suggest operator runbooks for an incident.')
+    .option('--service <name>', 'Filter to a specific service')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .option('--demo', 'Use demo data')
+    .action(async (incidentId, opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const params = {};
+    if (opts.service) params.service = opts.service;
+    try {
+        const data = isDemo(opts)
+            ? demoRunbookSuggest(incidentId, params.service)
+            : (await request('get', endpoint, `/runbooks/suggest/${encodeURIComponent(incidentId)}`, null, params))
+                  .data || {};
+        if (opts.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const incidentLabel = data.incident_id || incidentId;
+        console.log(chalk.cyan(`Runbook suggestions for ${incidentLabel}`));
+        if (data.title) {
+            console.log(`Incident: ${data.title}`);
+        }
+        const steps = Array.isArray(data.steps) ? data.steps : [];
+        if (steps.length === 0) {
+            console.log('No runbook steps available.');
+            if (shouldShowHints()) {
+                console.log(chalk.gray('Tip: store runbooks for this service or run with --demo.'));
+            }
+            return;
+        }
+        console.log('');
+        steps.forEach((step, index) => {
+            console.log(`${index + 1}) ${step.title || 'Step'}`);
+            if (step.command) console.log(`   ${step.command}`);
+            if (step.rationale) console.log(`   ${step.rationale}`);
+        });
+    } catch (e) {
+        printRequestError(e, 'Failed to suggest runbooks.', endpoint);
+    }
+});

package/src/commands/slos.js

@@ -0,0 +1,50 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const { resolveEndpoint, request } = require('../api');
+const { printRequestError, shouldShowHints } = require('../util');
+const { isDemo, demoSloStatus } = require('../demo');
+
+program.command('slos')
+    .description('Service-level objective commands.')
+    .command('status')
+    .description('Show current SLO status.')
+    .option('--project <name>', 'Filter to a project')
+    .option('--service <name>', 'Filter to a specific service')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .option('--demo', 'Use demo data')
+    .action(async (opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const params = {};
+    if (opts.project) params.project = opts.project;
+    if (opts.service) params.service = opts.service;
+    try {
+        const data = isDemo(opts)
+            ? demoSloStatus(opts.project)
+            : (await request('get', endpoint, '/slos/status', null, params)).data || {};
+        if (opts.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const project = data.project || opts.project || 'default';
+        const slos = Array.isArray(data.slos) ? data.slos : [];
+        console.log(chalk.cyan(`SLO Status (project: ${project})`));
+        if (slos.length === 0) {
+            console.log('No SLOs found.');
+            if (shouldShowHints()) {
+                console.log(chalk.gray('Tip: ingest SLO snapshots or run with --demo.'));
+            }
+            return;
+        }
+        slos.forEach((slo) => {
+            const service = slo.service || 'unknown';
+            const availability = Number.isFinite(slo.availability) ? `${slo.availability.toFixed(2)}%` : 'n/a';
+            const budget = Number.isFinite(slo.budget_left_pct) ? `${slo.budget_left_pct}%` : 'n/a';
+            const burn = Number.isFinite(slo.burn_rate) ? `${slo.burn_rate}x` : 'n/a';
+            const ttb = slo.time_to_breach || 'n/a';
+            console.log(`service/${service}  avail: ${availability}  budget left: ${budget}  burn: ${burn}  time-to-breach: ${ttb}`);
+        });
+    } catch (e) {
+        printRequestError(e, 'Failed to fetch SLO status.', endpoint);
+    }
+});

package/src/commands/status.js

@@ -0,0 +1,116 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const { resolveEndpoint, request } = require('../api');
+const { toInt, printRequestError, shouldShowHints } = require('../util');
+
+program.command('status')
+    .description('Show a clear health summary.')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    try {
+        const metricsResponse = await request('get', endpoint, '/metrics');
+        const metrics = Array.isArray(metricsResponse.data) ? metricsResponse.data : [];
+        let incident = null;
+        try {
+            const incidentResponse = await request('get', endpoint, '/incidents');
+            incident = incidentResponse.data || null;
+        } catch (e) {
+            incident = null;
+        }
+        const healthy = metrics.length > 0;
+        const healthLabel = healthy ? 'healthy' : 'degraded';
+        const statusLabel = healthy ? 'All systems operational' : 'Waiting for telemetry';
+        const payload = {
+            endpoint,
+            health: healthLabel,
+            status: statusLabel,
+            metrics: {
+                count: metrics.length,
+                latest: metrics[0] || null
+            },
+            incident
+        };
+        if (opts.json) {
+            console.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+    const status = await checkSystemStatus(opts.endpoint);
+    
+    console.log(chalk.cyan('Gridpoint Analytics Status'));
+    console.log('---------------------------');
+    console.log(`System:   ${status.healthy ? chalk.green('ONLINE') : chalk.red('OFFLINE')}`);
+        console.log(`Endpoint: ${endpoint}`);
+        console.log(`Health: ${healthy ? chalk.green('healthy') : chalk.yellow('degraded')}`);
+        console.log(`Status: ${statusLabel}`);
+        console.log(`Recent metrics: ${metrics.length}`);
+        if (metrics[0]) {
+            console.log(`Latest metric: ${metrics[0].timestamp || 'unknown'} (cpu ${metrics[0].cpu_time || 'n/a'}, status ${metrics[0].status || 'n/a'})`);
+        } else {
+            console.log('Next step: gpxe metrics --watch 10');
+        }
+        if (incident) {
+            console.log(chalk.red(`Incident: ${incident.title || 'Untitled'} (${incident.status || 'unknown'})`));
+        } else {
+            console.log('Incident: none reported');
+        }
+    } catch (e) {
+        printRequestError(e, 'Unable to fetch status from endpoint.', endpoint);
+        if (shouldShowHints()) {
+            console.log(chalk.gray('Tip: run "gpxe config" to confirm endpoint/token.'));
+        }
+    }
+});
+
+program.command('metrics')
+    .description('List recent metrics or watch for new ones.')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--limit <count>', 'Number of rows to show', '10')
+    .option('--watch <seconds>', 'Poll interval in seconds')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+        const endpoint = resolveEndpoint(opts.endpoint);
+        const limit = toInt(opts.limit, 10);
+        const intervalSeconds = opts.watch ? toInt(opts.watch, 0) : 0;
+
+        const runOnce = async () => {
+            try {
+                const response = await request('get', endpoint, '/metrics');
+                const metrics = Array.isArray(response.data) ? response.data : [];
+                const rows = metrics.slice(0, Math.max(limit, 0));
+                const payload = { endpoint, count: metrics.length, metrics: rows };
+                if (opts.json) {
+                    console.log(JSON.stringify(payload, null, 2));
+                    return;
+                }
+                console.log(chalk.cyan(`Fetched ${metrics.length} metrics from ${endpoint}`));
+                if (rows.length === 0) {
+                    console.log('No metrics available.');
+                    return;
+                }
+                const hasService = rows.some((metric) => metric.service);
+                const hasLatency = rows.some((metric) => metric.p95_latency_ms !== undefined && metric.p95_latency_ms !== null);
+                const hasErrorRate = rows.some((metric) => metric.error_rate_pct !== undefined && metric.error_rate_pct !== null);
+                console.table(rows.map((metric) => {
+                    const row = {
+                        timestamp: metric.timestamp || 'unknown',
+                        cpu_time: metric.cpu_time ?? 'n/a',
+                        status: metric.status ?? 'n/a'
+                    };
+                    if (hasService) row.service = metric.service || 'n/a';
+                    if (hasLatency) row.p95_latency_ms = metric.p95_latency_ms ?? 'n/a';
+                    if (hasErrorRate) row.error_rate_pct = metric.error_rate_pct ?? 'n/a';
+                    return row;
+                }));
+            } catch (e) {
+                printRequestError(e, 'Failed to fetch metrics.', endpoint);
+            }
+        };
+
+        await runOnce();
+        if (intervalSeconds > 0) {
+            console.log(chalk.gray(`Watching metrics every ${intervalSeconds}s. Press Ctrl+C to stop.`));
+            setInterval(runOnce, intervalSeconds * 1000);
+        }
+    });

package/src/commands/support.js

@@ -0,0 +1,67 @@
+const { program } = require('commander');
+const { prompt } = require('enquirer');
+const chalk = require('chalk');
+const { resolveEndpoint, request } = require('../api');
+const { printRequestError } = require('../util');
+const { isDemo, demoSupportRequest } = require('../demo');
+
+const supportCommand = program.command('support').description('Support request commands.');
+
+supportCommand
+    .command('new')
+    .description('Open a new support request.')
+    .option('--topic <topic>', 'Support topic (billing, incident, access, etc.)', 'general')
+    .option('--subject <text>', 'Short subject line')
+    .option('--message <text>', 'Details for the support team')
+    .option('--email <email>', 'Contact email address')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .option('--demo', 'Use demo data')
+    .action(async (opts) => {
+    let subject = opts.subject;
+    let message = opts.message;
+    if (!subject && process.stdin.isTTY) {
+        const answers = await prompt({
+            type: 'input',
+            name: 'subject',
+            message: 'Support request subject:'
+        });
+        subject = answers.subject;
+    }
+    if (!message && process.stdin.isTTY) {
+        const answers = await prompt({
+            type: 'input',
+            name: 'message',
+            message: 'What should we know?'
+        });
+        message = answers.message;
+    }
+    if (!subject && !message) {
+        console.log(chalk.red('Provide a subject or message to open a request.'));
+        return;
+    }
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const payload = {
+        topic: opts.topic || 'general',
+        subject: subject || null,
+        message: message || null,
+        email: opts.email || null
+    };
+    try {
+        const data = isDemo(opts)
+            ? demoSupportRequest(payload.topic, payload.subject, payload.message, payload.email)
+            : (await request('post', endpoint, '/support/requests', payload)).data || {};
+        if (opts.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const requestData = data.request || payload;
+        console.log(chalk.cyan('Support request created'));
+        if (requestData.id) console.log(`ID: ${requestData.id}`);
+        console.log(`Topic: ${requestData.topic || payload.topic}`);
+        if (requestData.subject) console.log(`Subject: ${requestData.subject}`);
+        console.log(`Status: ${data.status || 'open'}`);
+    } catch (e) {
+        printRequestError(e, 'Failed to open support request.', endpoint);
+    }
+});

package/src/config.js

@@ -0,0 +1,35 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_PATH = path.join(os.homedir(), '.gridpoint-cli.json');
+const readConfig = () => {
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    } catch (e) {
+        return {};
+    }
+};
+const writeConfig = (data) => {
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(data));
+};
+const config = {
+    set: (k, v) => {
+        const data = readConfig();
+        data[k] = v;
+        writeConfig(data);
+    },
+    get: (k) => {
+        const data = readConfig();
+        return data[k] ?? null;
+    },
+    unset: (k) => {
+        const data = readConfig();
+        if (!(k in data)) return false;
+        delete data[k];
+        writeConfig(data);
+        return true;
+    }
+};
+
+module.exports = { config, CONFIG_PATH };