@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/schedule.js

@@ -0,0 +1,202 @@
+/**
+ * Schedule Command (G13)
+ *
+ * Manage periodic DevOps automation tasks (drift checks, cert expiry,
+ * cost reports) via a local schedule file.
+ *
+ * Usage:
+ *   nimbus schedule list
+ *   nimbus schedule add "0 8 * * *" "check for infra drift" [--name daily-drift]
+ *   nimbus schedule remove <id-or-name>
+ *   nimbus schedule run-now <id-or-name>
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+// ---------------------------------------------------------------------------
+// Storage
+// ---------------------------------------------------------------------------
+const SCHEDULE_FILE = join(homedir(), '.nimbus', 'schedules.json');
+function loadSchedules() {
+    if (!existsSync(SCHEDULE_FILE))
+        return [];
+    try {
+        return JSON.parse(readFileSync(SCHEDULE_FILE, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+function saveSchedules(schedules) {
+    mkdirSync(join(homedir(), '.nimbus'), { recursive: true });
+    writeFileSync(SCHEDULE_FILE, JSON.stringify(schedules, null, 2), 'utf-8');
+}
+// ---------------------------------------------------------------------------
+// Cron validation (5-field: min hour dom month dow)
+// ---------------------------------------------------------------------------
+function isValidCron(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return false;
+    const validPart = /^(\*|\d+(-\d+)?(\/\d+)?)(,(\*|\d+(-\d+)?(\/\d+)?))*$/;
+    return parts.every(p => validPart.test(p));
+}
+/**
+ * Estimate next run time in human-readable form (best-effort).
+ */
+function describeNextRun(cron) {
+    const [min, hour, dom, month, dow] = cron.split(/\s+/);
+    if (hour === '*' && min === '0')
+        return 'every hour at :00';
+    if (dom === '*' && month === '*' && dow === '*') {
+        if (hour !== '*' && min !== '*')
+            return `daily at ${hour}:${min.padStart(2, '0')}`;
+    }
+    if (dow !== '*') {
+        const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+        const dayName = days[parseInt(dow, 10)];
+        if (dayName && hour !== '*')
+            return `weekly on ${dayName} at ${hour}:${(min ?? '0').padStart(2, '0')}`;
+    }
+    return `cron: ${cron}`;
+}
+// ---------------------------------------------------------------------------
+// Subcommands
+// ---------------------------------------------------------------------------
+function scheduleList() {
+    const schedules = loadSchedules();
+    if (schedules.length === 0) {
+        console.log('No schedules configured.');
+        console.log('\nAdd one with:');
+        console.log('  nimbus schedule add "0 8 * * *" "check for infrastructure drift" --name daily-drift');
+        return;
+    }
+    console.log('Configured schedules:\n');
+    for (const s of schedules) {
+        console.log(`  ID:     ${s.id}`);
+        console.log(`  Name:   ${s.name}`);
+        console.log(`  Runs:   ${describeNextRun(s.cron)} (${s.cron})`);
+        console.log(`  Prompt: ${s.prompt.slice(0, 80)}${s.prompt.length > 80 ? '...' : ''}`);
+        console.log('');
+    }
+    console.log('To activate, add to crontab (crontab -e):');
+    for (const s of schedules) {
+        console.log(`  ${s.cron} nimbus schedule run-now ${s.id}`);
+    }
+}
+function scheduleAdd(cron, prompt, name) {
+    if (!cron || !prompt) {
+        console.error('Usage: nimbus schedule add "<cron>" "<prompt>" [--name <name>]');
+        process.exit(1);
+    }
+    if (!isValidCron(cron)) {
+        console.error(`Invalid cron expression: "${cron}"`);
+        console.error('Expected 5 fields: min hour day-of-month month day-of-week');
+        console.error('Example: "0 8 * * *" (daily at 8am)');
+        process.exit(1);
+    }
+    const schedules = loadSchedules();
+    const id = randomBytes(4).toString('hex');
+    const entryName = name ?? `schedule-${id}`;
+    const entry = {
+        id,
+        name: entryName,
+        cron,
+        prompt,
+        createdAt: new Date().toISOString(),
+    };
+    schedules.push(entry);
+    saveSchedules(schedules);
+    console.log(`Schedule added: ${entryName} (ID: ${id})`);
+    console.log(`Runs: ${describeNextRun(cron)}`);
+    console.log('');
+    console.log('To activate, add to crontab (crontab -e):');
+    console.log(`  ${cron} nimbus schedule run-now ${id}`);
+}
+function scheduleRemove(idOrName) {
+    const schedules = loadSchedules();
+    const idx = schedules.findIndex(s => s.id === idOrName || s.name === idOrName);
+    if (idx === -1) {
+        console.error(`Schedule not found: ${idOrName}`);
+        process.exit(1);
+    }
+    const removed = schedules.splice(idx, 1)[0];
+    saveSchedules(schedules);
+    console.log(`Removed schedule: ${removed.name} (${removed.id})`);
+}
+async function scheduleRunNow(idOrName) {
+    const schedules = loadSchedules();
+    const entry = schedules.find(s => s.id === idOrName || s.name === idOrName);
+    if (!entry) {
+        console.error(`Schedule not found: ${idOrName}`);
+        process.exit(1);
+    }
+    console.log(`Running schedule: ${entry.name}`);
+    console.log(`Prompt: ${entry.prompt}`);
+    console.log('');
+    const { executeRun, parseRunArgs } = await import('../cli/run');
+    const { getAppContext } = await import('../app');
+    const ctx = getAppContext();
+    if (!ctx) {
+        console.error('Error: App not initialised. Make sure credentials are configured.');
+        process.exit(1);
+    }
+    const runOptions = parseRunArgs(['--auto-approve', '--mode', 'build', entry.prompt]);
+    await executeRun(ctx.router, runOptions);
+}
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+export async function scheduleCommand(subcommand, args) {
+    switch (subcommand) {
+        case 'list':
+        case 'ls':
+            scheduleList();
+            break;
+        case 'add': {
+            // nimbus schedule add "<cron>" "<prompt>" [--name <name>]
+            const cron = args[0] ?? '';
+            const prompt = args[1] ?? '';
+            const nameIdx = args.indexOf('--name');
+            const name = nameIdx !== -1 ? args[nameIdx + 1] : undefined;
+            scheduleAdd(cron, prompt, name);
+            break;
+        }
+        case 'remove':
+        case 'rm':
+        case 'delete': {
+            const idOrName = args[0];
+            if (!idOrName) {
+                console.error('Usage: nimbus schedule remove <id-or-name>');
+                process.exit(1);
+            }
+            scheduleRemove(idOrName);
+            break;
+        }
+        case 'run-now':
+        case 'run': {
+            const idOrName = args[0];
+            if (!idOrName) {
+                console.error('Usage: nimbus schedule run-now <id-or-name>');
+                process.exit(1);
+            }
+            await scheduleRunNow(idOrName);
+            break;
+        }
+        default:
+            console.log('Usage: nimbus schedule <list|add|remove|run-now>');
+            console.log('');
+            console.log('  list                          List configured schedules');
+            console.log('  add "<cron>" "<prompt>"       Add a new schedule');
+            console.log('  remove <id-or-name>           Remove a schedule');
+            console.log('  run-now <id-or-name>          Execute a schedule immediately');
+            console.log('');
+            console.log('Examples:');
+            console.log('  nimbus schedule add "0 8 * * *" "check for infrastructure drift" --name daily-drift');
+            console.log('  nimbus schedule add "0 9 * * 1" "generate weekly cost report"');
+            console.log('  nimbus schedule list');
+            console.log('  nimbus schedule run-now daily-drift');
+            break;
+    }
+}

package/dist/src/commands/status.js

@@ -0,0 +1,213 @@
+/**
+ * nimbus status — Infrastructure Status Dashboard
+ *
+ * Runs concurrent checks against common DevOps CLIs and shows a dashboard
+ * of the current cloud/infra context.
+ *
+ * G18: New command added to the gap fix plan.
+ *
+ * Usage:
+ *   nimbus status
+ *   nimbus status --json
+ */
+import { ui } from '../wizard';
+/**
+ * Run the nimbus status command.
+ * Checks k8s context, tf workspace, AWS identity, and GCP project concurrently.
+ */
+export async function statusCommand(options = {}) {
+    const { execFileSync } = await import('node:child_process');
+    const { existsSync, statSync, readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const { homedir } = await import('node:os');
+    const info = { errors: [] };
+    const run = (cmd, args) => {
+        try {
+            return execFileSync(cmd, args, {
+                encoding: 'utf-8',
+                timeout: 8000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch {
+            return undefined;
+        }
+    };
+    // Run all checks concurrently (M1: add helm + pod health)
+    const [k8sCtx, tfWs, awsIdentityRaw, gcpProject, helmListRaw, podUnhealthyRaw] = await Promise.allSettled([
+        Promise.resolve(run('kubectl', ['config', 'current-context'])),
+        Promise.resolve(run('terraform', ['workspace', 'show'])),
+        Promise.resolve(run('aws', ['sts', 'get-caller-identity', '--output', 'json'])),
+        Promise.resolve(run('gcloud', ['config', 'get-value', 'project'])),
+        Promise.resolve(run('helm', ['list', '-A', '--output', 'json'])),
+        Promise.resolve(run('kubectl', ['get', 'pods', '-A', '--field-selector=status.phase!=Running', '--no-headers'])),
+    ]);
+    if (k8sCtx.status === 'fulfilled' && k8sCtx.value) {
+        info.k8sContext = k8sCtx.value;
+    }
+    if (tfWs.status === 'fulfilled' && tfWs.value) {
+        info.tfWorkspace = tfWs.value;
+    }
+    if (awsIdentityRaw.status === 'fulfilled' && awsIdentityRaw.value) {
+        try {
+            const identity = JSON.parse(awsIdentityRaw.value);
+            info.awsAccount = identity.Account;
+            // Try to get region separately
+            const region = run('aws', ['configure', 'get', 'region']);
+            if (region)
+                info.awsRegion = region;
+        }
+        catch {
+            // Could not parse AWS identity
+        }
+    }
+    if (gcpProject.status === 'fulfilled' && gcpProject.value && gcpProject.value !== '(unset)') {
+        info.gcpProject = gcpProject.value;
+    }
+    // M1: Parse helm release health
+    if (helmListRaw.status === 'fulfilled' && helmListRaw.value) {
+        try {
+            const releases = JSON.parse(helmListRaw.value);
+            info.helmTotalCount = releases.length;
+            info.helmFailedCount = releases.filter(r => r.status !== 'deployed').length;
+        }
+        catch { /* non-critical */ }
+    }
+    // M1: Parse unhealthy pod count
+    if (podUnhealthyRaw.status === 'fulfilled' && podUnhealthyRaw.value) {
+        const lines = podUnhealthyRaw.value.trim().split('\n').filter(Boolean);
+        info.unhealthyPodCount = lines.length;
+    }
+    // Check last drift scan from SQLite + session count
+    try {
+        const { getDb } = await import('../state/db');
+        const db = getDb();
+        const row = db.prepare(`
+      SELECT created_at FROM sessions
+      ORDER BY created_at DESC LIMIT 1
+    `).get();
+        if (row?.created_at) {
+            info.lastDriftScan = row.created_at;
+        }
+        // C2: Count sessions
+        const countRow = db.prepare('SELECT COUNT(*) as cnt FROM sessions').get();
+        info.sessionCount = countRow?.cnt ?? 0;
+    }
+    catch {
+        // DB not available
+        info.sessionCount = 'N/A';
+    }
+    // C2: Read model and provider from ~/.nimbus/config.json
+    const configJsonPath = join(homedir(), '.nimbus', 'config.json');
+    try {
+        if (existsSync(configJsonPath)) {
+            const configRaw = readFileSync(configJsonPath, 'utf-8');
+            const config = JSON.parse(configRaw);
+            info.model = typeof config.model === 'string' ? config.model : 'claude-sonnet-4-6';
+            info.provider = typeof config.provider === 'string' ? config.provider : 'anthropic';
+        }
+        else {
+            info.model = 'claude-sonnet-4-6';
+            info.provider = 'anthropic';
+        }
+    }
+    catch {
+        info.model = 'claude-sonnet-4-6';
+        info.provider = 'anthropic';
+    }
+    // C2: Check NIMBUS.md in cwd
+    const nimbusMdPaths = [
+        join(process.cwd(), 'NIMBUS.md'),
+        join(process.cwd(), '.nimbus', 'NIMBUS.md'),
+    ];
+    for (const p of nimbusMdPaths) {
+        try {
+            if (existsSync(p)) {
+                const stat = statSync(p);
+                info.nimbusMdFound = true;
+                info.nimbusMdSize = stat.size;
+                break;
+            }
+        }
+        catch { /* skip */ }
+    }
+    // C2: Get DB file size
+    const dbPath = join(homedir(), '.nimbus', 'nimbus.db');
+    try {
+        if (existsSync(dbPath)) {
+            const stat = statSync(dbPath);
+            info.dbSizeMB = Math.round((stat.size / (1024 * 1024)) * 10) / 10;
+        }
+    }
+    catch { /* skip */ }
+    if (options.json) {
+        console.log(JSON.stringify(info, null, 2));
+        return;
+    }
+    // Pretty-print dashboard
+    // Build session line
+    const sessionLine = typeof info.sessionCount === 'number'
+        ? `${info.sessionCount} sessions`
+        : 'N/A';
+    // Build NIMBUS.md line
+    const nimbusMdLine = info.nimbusMdFound && info.nimbusMdSize !== undefined
+        ? `  loaded (${info.nimbusMdSize >= 1024
+            ? `${(info.nimbusMdSize / 1024).toFixed(1)}KB`
+            : `${info.nimbusMdSize}B`})`
+        : '  not found';
+    // Build DB size line
+    const dbLine = info.dbSizeMB !== undefined
+        ? `~/.nimbus/nimbus.db (${info.dbSizeMB}MB)`
+        : '~/.nimbus/nimbus.db (not found)';
+    ui.newLine();
+    ui.box({
+        title: 'Nimbus Infrastructure Status',
+        content: [
+            '',
+            `  Session:   ${sessionLine}`,
+            `  Model:     ${info.model ?? 'claude-sonnet-4-6'}`,
+            `  Provider:  ${info.provider ?? 'anthropic'} \u2713`,
+            '',
+            '  Infrastructure:',
+            info.k8sContext
+                ? `    Kubernetes: context=${info.k8sContext}`
+                : '    Kubernetes:   (not configured)',
+            info.tfWorkspace
+                ? `    Terraform:  workspace=${info.tfWorkspace}  \u2713 initialized`
+                : '    Terraform:    (not in a terraform directory)',
+            info.awsAccount
+                ? `    AWS:        account=${info.awsAccount}${info.awsRegion ? `  region=${info.awsRegion}` : ''}`
+                : '    AWS:          (not configured)',
+            info.gcpProject
+                ? `    GCP:        project=${info.gcpProject}`
+                : '',
+            // M1: Helm release health
+            ...(info.helmTotalCount !== undefined
+                ? [
+                    info.helmFailedCount && info.helmFailedCount > 0
+                        ? `  [!] ${info.helmFailedCount} Helm release(s) in failed state (${info.helmTotalCount} total)`
+                        : `    Helm:       ${info.helmTotalCount} release(s) deployed`,
+                ]
+                : []),
+            // M1: Pod health warnings
+            ...(info.unhealthyPodCount !== undefined && info.unhealthyPodCount > 0
+                ? [`  [!] ${info.unhealthyPodCount} pod(s) not running`]
+                : []),
+            '',
+            `  NIMBUS.md:${nimbusMdLine}`,
+            `  DB:        ${dbLine}`,
+            '',
+            info.lastDriftScan
+                ? `  Last session: ${new Date(info.lastDriftScan).toLocaleString()}`
+                : '  Last session: (none)',
+            '',
+            '  Quick actions: nimbus plan | nimbus apply | nimbus logs',
+            '',
+        ].filter(line => line !== undefined),
+        style: 'rounded',
+        borderColor: 'cyan',
+        padding: 0,
+    });
+    ui.newLine();
+}
+export default statusCommand;