@dotsetlabs/bellwether 0.10.0

package/dist/cli/commands/beta.js

@@ -0,0 +1,231 @@
+/**
+ * Beta command for Bellwether Cloud beta access management.
+ *
+ * Subcommands:
+ * - status: Check beta status and user's access
+ * - invite <code>: Enter and verify an invitation code
+ */
+import { Command } from 'commander';
+import { getStoredSession, getBaseUrl, isMockSession, } from '../../cloud/auth.js';
+import * as output from '../output.js';
+export const betaCommand = new Command('beta')
+    .description('Manage beta access for Bellwether Cloud')
+    .addHelpText('after', `
+Examples:
+  bellwether beta status           # Check if beta mode is enabled and your access
+  bellwether beta invite ABCD-1234 # Verify an invitation code
+`);
+/**
+ * Check if beta mode is enabled.
+ */
+async function checkBetaStatus() {
+    const baseUrl = getBaseUrl();
+    try {
+        const response = await fetch(`${baseUrl}/beta/status`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            return { betaMode: false };
+        }
+        return response.json();
+    }
+    catch {
+        return { betaMode: false };
+    }
+}
+/**
+ * Check if current user has beta access.
+ */
+async function checkBetaAccess(sessionToken) {
+    const baseUrl = getBaseUrl();
+    try {
+        const response = await fetch(`${baseUrl}/beta/access`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${sessionToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return response.json();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Verify a beta invite code.
+ */
+async function verifyBetaInvite(code) {
+    const baseUrl = getBaseUrl();
+    try {
+        const response = await fetch(`${baseUrl}/beta/verify-invite`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ code }),
+        });
+        if (!response.ok) {
+            return { valid: false, message: 'Failed to verify invitation code' };
+        }
+        return response.json();
+    }
+    catch (err) {
+        return { valid: false, message: 'Could not connect to server' };
+    }
+}
+/**
+ * Accept a beta invite (requires authentication).
+ */
+async function acceptBetaInvite(sessionToken, code) {
+    const baseUrl = getBaseUrl();
+    try {
+        const response = await fetch(`${baseUrl}/beta/accept`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${sessionToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ code }),
+        });
+        const result = await response.json();
+        if (!response.ok) {
+            return {
+                success: false,
+                message: result.message || result.error || 'Failed to accept invitation',
+            };
+        }
+        return {
+            success: result.success ?? true,
+            message: result.message ?? 'Beta access granted',
+        };
+    }
+    catch {
+        return { success: false, message: 'Could not connect to server' };
+    }
+}
+// Subcommand: status
+betaCommand
+    .command('status')
+    .description('Check if beta mode is enabled and your access level')
+    .action(async () => {
+    try {
+        // Check if beta mode is enabled
+        const betaStatus = await checkBetaStatus();
+        output.info('Beta Status');
+        output.info('-----------');
+        output.info(`Beta Mode: ${betaStatus.betaMode ? 'Enabled' : 'Disabled'}`);
+        if (!betaStatus.betaMode) {
+            output.info('\nBellwether Cloud is open to all users.');
+            return;
+        }
+        // Check if user is logged in
+        const session = getStoredSession();
+        if (!session) {
+            output.info('\nYou are not logged in.');
+            output.info('Run `bellwether login` to authenticate.');
+            output.info('\nTo request beta access, visit https://bellwether.sh');
+            return;
+        }
+        // Check user's beta access
+        if (isMockSession(session.sessionToken)) {
+            output.info('\nUsing mock session - beta access not applicable.');
+            return;
+        }
+        const betaAccess = await checkBetaAccess(session.sessionToken);
+        if (betaAccess === null) {
+            output.info('\nCould not check beta access status.');
+            return;
+        }
+        output.info(`\nLogged in as: ${session.user.githubLogin}`);
+        output.info(`Beta Access: ${betaAccess.hasBetaAccess ? 'Yes' : 'No'}`);
+        if (betaAccess.isAdmin) {
+            output.info('Admin Access: Yes');
+        }
+        if (!betaAccess.hasBetaAccess) {
+            output.info('\nYou do not have beta access.');
+            output.info('If you have an invitation code, run:');
+            output.info('  bellwether beta invite <code>');
+            output.info('\nOr join the waitlist at https://bellwether.sh');
+        }
+    }
+    catch (err) {
+        output.error('Failed to check beta status: ' + (err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+});
+// Subcommand: invite
+betaCommand
+    .command('invite <code>')
+    .description('Verify and accept a beta invitation code')
+    .action(async (code) => {
+    try {
+        // Normalize code format (uppercase, add dash if missing)
+        let normalizedCode = code.toUpperCase().trim();
+        if (normalizedCode.length === 8 && !normalizedCode.includes('-')) {
+            normalizedCode = `${normalizedCode.slice(0, 4)}-${normalizedCode.slice(4)}`;
+        }
+        output.info(`Verifying invitation code: ${normalizedCode}\n`);
+        // First verify the code is valid
+        const verifyResult = await verifyBetaInvite(normalizedCode);
+        if (!verifyResult.valid) {
+            output.error('Invalid or expired invitation code.');
+            output.info(verifyResult.message || '');
+            output.info('\nMake sure you entered the code correctly (format: XXXX-XXXX)');
+            output.info('If your code has expired, request a new one from the person who invited you.');
+            process.exit(1);
+        }
+        output.info('Invitation code verified!');
+        if (verifyResult.invite) {
+            output.info(`Invite email: ${verifyResult.invite.email}`);
+            const expiresAt = new Date(verifyResult.invite.expiresAt);
+            output.info(`Expires: ${expiresAt.toLocaleDateString()}`);
+        }
+        // Check if user is logged in
+        const session = getStoredSession();
+        if (!session) {
+            output.info('\nTo accept this invitation, you need to log in first.');
+            output.info('Run: bellwether login');
+            output.info('\nDuring login, you will be prompted to enter your invitation code.');
+            return;
+        }
+        if (isMockSession(session.sessionToken)) {
+            output.info('\nUsing mock session - cannot accept real invitations.');
+            output.info('Run `bellwether login --logout` then `bellwether login` to use a real session.');
+            return;
+        }
+        // Try to accept the invitation
+        output.info('\nAccepting invitation...');
+        const acceptResult = await acceptBetaInvite(session.sessionToken, normalizedCode);
+        if (!acceptResult.success) {
+            output.error('Failed to accept invitation: ' + acceptResult.message);
+            // Check if it's an email mismatch
+            if (acceptResult.message.toLowerCase().includes('different email')) {
+                output.info('\nThe invitation was sent to a different email address.');
+                output.info(`You are logged in as: ${session.user.email || session.user.githubLogin}`);
+                output.info('\nMake sure your GitHub account uses the same email as the invitation.');
+            }
+            process.exit(1);
+        }
+        output.info('\nBeta access granted!');
+        output.info('You now have full access to all Bellwether Cloud features.');
+        output.info('\nGet started:');
+        output.info('  bellwether link <project>  # Link a project');
+        output.info('  bellwether upload          # Upload a baseline');
+    }
+    catch (err) {
+        output.error('Failed to process invitation: ' + (err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+});
+// Default action (no subcommand)
+betaCommand.action(() => {
+    betaCommand.outputHelp();
+});
+//# sourceMappingURL=beta.js.map

package/dist/cli/commands/check.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Check command - Schema validation and drift detection for MCP servers.
+ *
+ * Purpose: Fast, free, deterministic checking of MCP server contracts.
+ * Output: Documentation + JSON report (filenames configurable via output.files)
+ * Baseline: Full support (save, compare, diff)
+ * LLM: None required
+ */
+import { Command } from 'commander';
+export declare const checkCommand: Command;
+//# sourceMappingURL=check.d.ts.map