@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/upgrade.js

@@ -0,0 +1,515 @@
+/**
+ * Upgrade Command
+ *
+ * Checks for the latest Nimbus version and offers to upgrade.
+ * Supports npm registry, GitHub Releases binary download, and Homebrew.
+ *
+ * Detects the installation method and executes the appropriate upgrade
+ * command automatically (with user confirmation unless --force is passed).
+ */
+import { VERSION } from '../version';
+/** GitHub repository used for release downloads. */
+const GITHUB_REPO = 'the-ai-project-co/nimbus';
+/** npm package name (may not be published yet). */
+const NPM_PACKAGE = '@build-astron-co/nimbus';
+/** Homebrew tap name for the formula. */
+const HOMEBREW_TAP = 'the-ai-project-co/tap/nimbus';
+// ---------------------------------------------------------------------------
+// ANSI helpers (avoid importing the full wizard/ui for this standalone command)
+// ---------------------------------------------------------------------------
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+};
+function bold(s) {
+    return `${c.bold}${s}${c.reset}`;
+}
+function green(s) {
+    return `${c.green}${s}${c.reset}`;
+}
+function yellow(s) {
+    return `${c.yellow}${s}${c.reset}`;
+}
+function red(s) {
+    return `${c.red}${s}${c.reset}`;
+}
+function dim(s) {
+    return `${c.dim}${s}${c.reset}`;
+}
+function cyan(s) {
+    return `${c.cyan}${s}${c.reset}`;
+}
+// ---------------------------------------------------------------------------
+// Spinner
+// ---------------------------------------------------------------------------
+const SPINNER_FRAMES = [
+    '\u28CB',
+    '\u2819',
+    '\u2839',
+    '\u2838',
+    '\u283C',
+    '\u2834',
+    '\u2826',
+    '\u2827',
+    '\u2807',
+    '\u280F',
+];
+function startSpinner(message) {
+    let frame = 0;
+    let currentMsg = message;
+    const interval = setInterval(() => {
+        const f = cyan(SPINNER_FRAMES[frame % SPINNER_FRAMES.length]);
+        process.stderr.write(`\r\x1b[K  ${f} ${currentMsg}`);
+        frame++;
+    }, 80);
+    return {
+        update(msg) {
+            currentMsg = msg;
+        },
+        success(msg) {
+            clearInterval(interval);
+            process.stderr.write(`\r\x1b[K  ${green('\u2714')} ${msg}\n`);
+        },
+        fail(msg) {
+            clearInterval(interval);
+            process.stderr.write(`\r\x1b[K  ${red('\u2716')} ${msg}\n`);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Confirmation prompt
+// ---------------------------------------------------------------------------
+async function confirmPrompt(message, defaultYes = true) {
+    const { createInterface } = await import('node:readline');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const hint = defaultYes ? '[Y/n]' : '[y/N]';
+    return new Promise(resolve => {
+        rl.question(`  ${message} ${hint} `, answer => {
+            rl.close();
+            const trimmed = answer.trim().toLowerCase();
+            if (!trimmed) {
+                resolve(defaultYes);
+            }
+            else {
+                resolve(trimmed === 'y' || trimmed === 'yes');
+            }
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Version fetching
+// ---------------------------------------------------------------------------
+/**
+ * Try fetching the latest version from the npm registry.
+ * Returns the version string on success, or `null` when the package is not
+ * published or the registry is unreachable.
+ */
+async function fetchNpmVersion() {
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = (await response.json());
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Try fetching the latest release tag from GitHub Releases.
+ * Returns the tag name (e.g. `'v0.3.0'`) on success, or `null` when the
+ * API is unreachable or there are no releases.
+ */
+async function fetchGitHubReleaseVersion() {
+    try {
+        const response = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, {
+            headers: { Accept: 'application/vnd.github+json' },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = (await response.json());
+        // Strip leading 'v' from tag name (e.g. 'v0.3.0' -> '0.3.0')
+        const tag = data.tag_name ?? null;
+        return tag ? tag.replace(/^v/, '') : null;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Changelog fetching
+// ---------------------------------------------------------------------------
+/**
+ * Fetch the raw CHANGELOG.md from GitHub. Returns the last ~20 lines on success,
+ * or null if unavailable.
+ */
+async function fetchChangelog() {
+    try {
+        const urls = [
+            `https://raw.githubusercontent.com/${GITHUB_REPO}/main/CHANGELOG.md`,
+            `https://raw.githubusercontent.com/${GITHUB_REPO}/main/CHANGELOG`,
+        ];
+        for (const url of urls) {
+            const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+            if (response.ok) {
+                const text = await response.text();
+                const lines = text.split('\n');
+                // Return last 20 lines or the full content if shorter
+                return lines.slice(-20).join('\n');
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Detect how nimbus was installed by probing Homebrew, npm, bun, and the
+ * binary path.  Detection commands are given a short timeout so they never
+ * block the CLI for too long.
+ */
+async function detectInstallMethod() {
+    const { execSync } = await import('node:child_process');
+    const execOpts = {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10_000,
+    };
+    // 1. Homebrew
+    try {
+        const brewList = execSync('brew list --formula 2>/dev/null', execOpts);
+        if (brewList.includes('nimbus')) {
+            return { method: 'homebrew', detail: `Homebrew formula (${HOMEBREW_TAP})` };
+        }
+    }
+    catch {
+        /* not homebrew */
+    }
+    // 2. npm global
+    try {
+        const npmList = execSync(`npm list -g ${NPM_PACKAGE} 2>/dev/null`, execOpts);
+        if (npmList.includes(NPM_PACKAGE)) {
+            return { method: 'npm', detail: `npm global package (${NPM_PACKAGE})` };
+        }
+    }
+    catch {
+        /* not npm */
+    }
+    // 3. bun global
+    try {
+        const bunList = execSync('bun pm ls -g 2>/dev/null', execOpts);
+        if (bunList.includes(NPM_PACKAGE)) {
+            return { method: 'bun', detail: `bun global package (${NPM_PACKAGE})` };
+        }
+    }
+    catch {
+        /* not bun */
+    }
+    // 4. Compiled binary (not running through bun/node)
+    const argv0 = process.argv[0] ?? '';
+    const isBinary = !argv0.includes('bun') && !argv0.includes('node');
+    if (isBinary) {
+        return { method: 'binary', detail: `standalone binary (${argv0 || '/usr/local/bin/nimbus'})` };
+    }
+    return { method: 'unknown', detail: 'could not determine installation method' };
+}
+// ---------------------------------------------------------------------------
+// Upgrade execution helpers
+// ---------------------------------------------------------------------------
+/**
+ * Run a shell command, streaming output to the terminal.
+ * Throws on non-zero exit code.
+ */
+async function runShellCommand(cmd, timeoutMs = 120_000) {
+    const { execSync } = await import('node:child_process');
+    execSync(cmd, { stdio: 'inherit', timeout: timeoutMs });
+}
+/**
+ * Verify the upgrade by checking the installed version.
+ * Returns the new version string, or null if verification failed.
+ */
+async function verifyUpgrade() {
+    const { execSync } = await import('node:child_process');
+    try {
+        const output = execSync('nimbus --version 2>/dev/null', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 10_000,
+        });
+        // Output looks like "nimbus 0.3.0" or just "0.3.0"
+        const match = output.trim().match(/(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Execute the upgrade via Homebrew.
+ */
+async function upgradeViaHomebrew(spinner) {
+    spinner.update('Updating Homebrew tap...');
+    try {
+        await runShellCommand(`brew upgrade ${HOMEBREW_TAP} 2>&1`);
+    }
+    catch {
+        // If the tap formula isn't found, try the short name
+        spinner.update('Trying brew upgrade nimbus...');
+        await runShellCommand('brew upgrade nimbus 2>&1');
+    }
+}
+/**
+ * Execute the upgrade via npm.
+ */
+async function upgradeViaNpm(spinner) {
+    spinner.update(`Installing ${NPM_PACKAGE}@latest via npm...`);
+    await runShellCommand(`npm install -g ${NPM_PACKAGE}@latest 2>&1`);
+}
+/**
+ * Execute the upgrade via bun.
+ */
+async function upgradeViaBun(spinner) {
+    spinner.update(`Installing ${NPM_PACKAGE}@latest via bun...`);
+    await runShellCommand(`bun install -g ${NPM_PACKAGE}@latest 2>&1`);
+}
+/**
+ * Execute the upgrade by downloading a compiled binary from GitHub Releases.
+ */
+async function upgradeViaBinaryDownload(latestVersion, spinner) {
+    const platform = process.platform === 'darwin' ? 'darwin' : process.platform === 'linux' ? 'linux' : null;
+    const arch = process.arch === 'arm64' ? 'arm64' : process.arch === 'x64' ? 'x64' : null;
+    if (!platform || !arch) {
+        throw new Error(`Unsupported platform/architecture: ${process.platform}/${process.arch}. ` +
+            `Please download the binary manually from https://github.com/${GITHUB_REPO}/releases/latest`);
+    }
+    const assetName = `nimbus-${platform}-${arch}`;
+    const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/v${latestVersion}/${assetName}`;
+    const binaryPath = process.argv[0] || '/usr/local/bin/nimbus';
+    const tmpPath = `${binaryPath}.upgrade-tmp`;
+    spinner.update(`Downloading ${assetName} v${latestVersion}...`);
+    // Download to a temp file, make executable, then atomically replace
+    const cmd = [
+        `curl -fsSL "${downloadUrl}" -o "${tmpPath}"`,
+        `chmod +x "${tmpPath}"`,
+        `mv "${tmpPath}" "${binaryPath}"`,
+    ].join(' && ');
+    try {
+        await runShellCommand(cmd, 120_000);
+    }
+    catch (err) {
+        // Clean up temp file on failure
+        try {
+            const fs = await import('node:fs');
+            if (fs.existsSync(tmpPath)) {
+                fs.unlinkSync(tmpPath);
+            }
+        }
+        catch {
+            /* best effort */
+        }
+        throw err;
+    }
+}
+// ---------------------------------------------------------------------------
+// Main upgrade command
+// ---------------------------------------------------------------------------
+/**
+ * Check for and install the latest version of Nimbus.
+ */
+export async function upgradeCommand(options = {}) {
+    console.log(`Current version: ${bold(VERSION)}`);
+    console.log('Checking for updates...\n');
+    // Try npm registry first, then fall back to GitHub Releases
+    let latestVersion = await fetchNpmVersion();
+    let source = latestVersion ? 'npm' : 'none';
+    if (!latestVersion) {
+        latestVersion = await fetchGitHubReleaseVersion();
+        if (latestVersion) {
+            source = 'github';
+        }
+    }
+    if (!latestVersion) {
+        console.log('No updates available (package not yet published to npm, and no GitHub releases found).');
+        console.log(`You are on version ${VERSION}.`);
+        return;
+    }
+    if (latestVersion === VERSION) {
+        console.log(green(`You're already on the latest version (${VERSION}).`));
+        return;
+    }
+    // Simple semver comparison to check if remote is actually newer
+    const currentParts = VERSION.split('.').map(Number);
+    const remoteParts = latestVersion.split('.').map(Number);
+    let isNewer = false;
+    for (let i = 0; i < 3; i++) {
+        if ((remoteParts[i] ?? 0) > (currentParts[i] ?? 0)) {
+            isNewer = true;
+            break;
+        }
+        if ((remoteParts[i] ?? 0) < (currentParts[i] ?? 0)) {
+            break;
+        }
+    }
+    if (!isNewer) {
+        console.log(green(`You're already on the latest version (${VERSION}).`));
+        return;
+    }
+    console.log(`${yellow('New version available:')} ${dim(VERSION)} ${dim('->')} ${bold(green(latestVersion))}`);
+    if (source === 'github') {
+        console.log(dim(`  Source: GitHub Releases (https://github.com/${GITHUB_REPO}/releases)`));
+    }
+    console.log('');
+    // --dry-run: show what would be upgraded without upgrading
+    if (options.dryRun) {
+        console.log(`${yellow('Dry run:')} Current: ${bold(VERSION)} → Latest: ${bold(green(latestVersion))}`);
+        console.log(dim(`  Source: ${source === 'github' ? 'GitHub Releases' : 'npm registry'}`));
+        console.log('');
+        console.log(dim('No changes were made. Remove --dry-run to perform the upgrade.'));
+        return;
+    }
+    // --changelog: fetch and display the changelog
+    if (options.changelog) {
+        console.log(bold(`Changelog for nimbus ${latestVersion}:`));
+        console.log('');
+        const cl = await fetchChangelog();
+        if (cl) {
+            console.log(cl);
+        }
+        else {
+            console.log(dim(`Changelog not available. View releases at: https://github.com/${GITHUB_REPO}/releases`));
+        }
+        return;
+    }
+    if (options.check) {
+        return;
+    }
+    // Detect how nimbus was installed
+    const detection = await detectInstallMethod();
+    console.log(`Detected installation: ${bold(detection.detail)}`);
+    console.log('');
+    // For unknown install methods, just print manual instructions
+    if (detection.method === 'unknown') {
+        printManualInstructions(source);
+        return;
+    }
+    // Ask for confirmation unless --force
+    if (!options.force) {
+        const proceed = await confirmPrompt(`Upgrade nimbus ${VERSION} -> ${latestVersion}?`, true);
+        if (!proceed) {
+            console.log('\nUpgrade cancelled.');
+            return;
+        }
+        console.log('');
+    }
+    // Execute the upgrade
+    const spinner = startSpinner('Upgrading nimbus...');
+    try {
+        switch (detection.method) {
+            case 'homebrew':
+                await upgradeViaHomebrew(spinner);
+                break;
+            case 'npm':
+                await upgradeViaNpm(spinner);
+                break;
+            case 'bun':
+                await upgradeViaBun(spinner);
+                break;
+            case 'binary':
+                if (source !== 'github') {
+                    spinner.fail('Binary upgrade requires GitHub Releases, but no release was found.');
+                    printManualInstructions(source);
+                    return;
+                }
+                await upgradeViaBinaryDownload(latestVersion, spinner);
+                break;
+        }
+        spinner.success('Upgrade command completed');
+    }
+    catch (error) {
+        const msg = error.message || String(error);
+        spinner.fail(`Upgrade failed: ${msg}`);
+        console.log('');
+        // Provide recovery instructions
+        console.log(yellow('You can try upgrading manually:'));
+        printUpgradeInstructionForMethod(detection.method, latestVersion, source);
+        return;
+    }
+    // Verify the upgrade succeeded
+    console.log('');
+    const verifySpinner = startSpinner('Verifying upgrade...');
+    const newVersion = await verifyUpgrade();
+    if (newVersion && newVersion === latestVersion) {
+        verifySpinner.success(`Successfully upgraded to ${bold(green(newVersion))}`);
+    }
+    else if (newVersion && newVersion !== VERSION) {
+        verifySpinner.success(`Upgraded to ${bold(green(newVersion))}`);
+    }
+    else if (detection.method === 'binary') {
+        // For binary upgrades, the current process is the old binary so
+        // `nimbus --version` will report the new version only on next launch.
+        verifySpinner.success(`Binary replaced. Restart nimbus to use ${bold(green(latestVersion))}.`);
+    }
+    else {
+        verifySpinner.fail('Could not verify the new version. Please run `nimbus --version` to check.');
+    }
+}
+// ---------------------------------------------------------------------------
+// Helper: print manual instructions (fallback for unknown install method)
+// ---------------------------------------------------------------------------
+function printManualInstructions(source) {
+    console.log('Could not detect installation method. Upgrade manually:');
+    console.log('');
+    console.log(`  ${dim('# npm')}`);
+    console.log(`  npm install -g ${NPM_PACKAGE}@latest`);
+    console.log('');
+    console.log(`  ${dim('# bun')}`);
+    console.log(`  bun install -g ${NPM_PACKAGE}@latest`);
+    console.log('');
+    console.log(`  ${dim('# Homebrew')}`);
+    console.log(`  brew upgrade ${HOMEBREW_TAP}`);
+    if (source === 'github') {
+        console.log('');
+        console.log(`  ${dim('# Binary download')}`);
+        console.log(`  https://github.com/${GITHUB_REPO}/releases/latest`);
+    }
+}
+/**
+ * Print the specific upgrade instruction for a detected method (used after
+ * an automatic upgrade fails).
+ */
+function printUpgradeInstructionForMethod(method, latestVersion, source) {
+    switch (method) {
+        case 'homebrew':
+            console.log(`  brew upgrade ${HOMEBREW_TAP}`);
+            break;
+        case 'npm':
+            console.log(`  npm install -g ${NPM_PACKAGE}@latest`);
+            break;
+        case 'bun':
+            console.log(`  bun install -g ${NPM_PACKAGE}@latest`);
+            break;
+        case 'binary': {
+            const platform = process.platform === 'darwin' ? 'darwin' : 'linux';
+            const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+            const assetName = `nimbus-${platform}-${arch}`;
+            const url = `https://github.com/${GITHUB_REPO}/releases/download/v${latestVersion}/${assetName}`;
+            console.log(`  curl -fsSL "${url}" -o /usr/local/bin/nimbus && chmod +x /usr/local/bin/nimbus`);
+            break;
+        }
+        default:
+            printManualInstructions(source);
+            break;
+    }
+}

package/dist/src/commands/usage/index.js

@@ -0,0 +1,118 @@
+/**
+ * Usage Command
+ * Usage dashboard CLI command
+ */
+import { ui } from '../../wizard/ui';
+import { billingClient } from '../../clients/enterprise-client';
+/**
+ * Get current team ID from config or environment
+ */
+function getCurrentTeamId() {
+    return process.env.NIMBUS_TEAM_ID || null;
+}
+/**
+ * Parse usage options
+ */
+export function parseUsageOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--period' && args[i + 1]) {
+            options.period = args[++i];
+        }
+        else if (arg === '--team' && args[i + 1]) {
+            options.teamId = args[++i];
+        }
+        else if (arg === '--json') {
+            options.json = true;
+        }
+        else if (arg === '--non-interactive') {
+            options.nonInteractive = true;
+        }
+    }
+    return options;
+}
+/**
+ * Format number with commas
+ */
+function formatNumber(n) {
+    return n.toLocaleString();
+}
+/**
+ * Format cost in USD
+ */
+function formatCost(n) {
+    return `$${n.toFixed(2)}`;
+}
+/**
+ * Usage command
+ */
+export async function usageCommand(options) {
+    try {
+        const teamId = options.teamId || getCurrentTeamId();
+        if (!teamId) {
+            ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+            ui.info('Or use: nimbus usage --team <team-id>');
+            return;
+        }
+        const period = options.period || 'month';
+        ui.startSpinner({ message: `Fetching ${period} usage...` });
+        const usage = await billingClient.getUsage(teamId, period);
+        ui.stopSpinnerSuccess('Usage retrieved');
+        if (options.json) {
+            console.log(JSON.stringify(usage, null, 2));
+            return;
+        }
+        ui.newLine();
+        ui.header('Usage Dashboard', `${new Date(usage.period.start).toLocaleDateString()} - ${new Date(usage.period.end).toLocaleDateString()}`);
+        // Summary
+        ui.section('Summary');
+        ui.print(`  Total Operations: ${formatNumber(usage.totals.operations)}`);
+        ui.print(`  Total Tokens:     ${formatNumber(usage.totals.tokensUsed)}`);
+        ui.print(`  Total Cost:       ${formatCost(usage.totals.costUsd)}`);
+        // By operation type
+        const operationTypes = Object.entries(usage.byOperationType);
+        if (operationTypes.length > 0) {
+            ui.section('By Operation Type');
+            ui.table({
+                columns: [
+                    { key: 'type', header: 'Operation' },
+                    { key: 'count', header: 'Count' },
+                    { key: 'tokens', header: 'Tokens' },
+                    { key: 'cost', header: 'Cost' },
+                ],
+                data: operationTypes.map(([type, data]) => ({
+                    type,
+                    count: formatNumber(data.count),
+                    tokens: formatNumber(data.tokensUsed),
+                    cost: formatCost(data.costUsd),
+                })),
+            });
+        }
+        // By user (if available)
+        if (usage.byUser && Object.keys(usage.byUser).length > 0) {
+            const userUsage = Object.entries(usage.byUser);
+            ui.section('By User');
+            ui.table({
+                columns: [
+                    { key: 'user', header: 'User' },
+                    { key: 'count', header: 'Operations' },
+                    { key: 'tokens', header: 'Tokens' },
+                    { key: 'cost', header: 'Cost' },
+                ],
+                data: userUsage.map(([user, data]) => ({
+                    user,
+                    count: formatNumber(data.count),
+                    tokens: formatNumber(data.tokensUsed),
+                    cost: formatCost(data.costUsd),
+                })),
+            });
+        }
+        ui.newLine();
+        ui.dim(`Period: ${period} | Use --period day|week|month to change`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to get usage');
+        ui.error(error.message);
+    }
+}