@vee-stack/delta-cli 2.0.8 → 2.0.10

package/dist/apps/cli/src/ui.js

@@ -1,219 +0,0 @@
-/**
- * Professional UI Components for Delta CLI
- */
-import chalk from 'chalk';
-import ora from 'ora';
-import Table from 'cli-table3';
-import prompts from 'prompts';
-// Icons and symbols
-export const icons = {
-    success: chalk.green('✔'),
-    error: chalk.red('✖'),
-    warning: chalk.yellow('⚠'),
-    info: chalk.blue('ℹ'),
-    arrow: chalk.cyan('→'),
-    bullet: chalk.dim('•'),
-    star: chalk.yellow('★'),
-    check: chalk.green('✓'),
-    cross: chalk.red('✗'),
-    loading: chalk.cyan('⏳'),
-    rocket: chalk.magenta('🚀'),
-    lock: chalk.yellow('🔒'),
-    user: chalk.blue('👤'),
-    package: chalk.cyan('📦'),
-    chart: chalk.green('📊'),
-    folder: chalk.yellow('📁'),
-    gear: chalk.gray('⚙️'),
-    link: chalk.blue('🔗'),
-    sparkles: chalk.yellow('✨'),
-    dot: chalk.cyan('⏵'),
-};
-// Spinner management
-let currentSpinner = null;
-export function startSpinner(text) {
-    if (currentSpinner) {
-        currentSpinner.stop();
-    }
-    currentSpinner = ora({
-        text: chalk.cyan(text),
-        spinner: 'dots',
-        color: 'cyan',
-    }).start();
-    return currentSpinner;
-}
-export function stopSpinner(success = true, text) {
-    if (currentSpinner) {
-        if (success) {
-            currentSpinner.succeed(text ? chalk.green(text) : undefined);
-        }
-        else {
-            currentSpinner.fail(text ? chalk.red(text) : undefined);
-        }
-        currentSpinner = null;
-    }
-}
-export function updateSpinnerText(text) {
-    if (currentSpinner) {
-        currentSpinner.text = chalk.cyan(text);
-    }
-}
-// Headers and sections
-export function printHeader(title) {
-    console.log();
-    console.log(chalk.bold(chalk.cyan(`  ${icons.rocket} ${title}`)));
-    console.log(chalk.dim('  ' + '─'.repeat(title.length + 4)));
-}
-export function printSection(title) {
-    console.log();
-    console.log(chalk.bold(chalk.white(`  ${icons.dot} ${title}`)));
-}
-export function printSubSection(title) {
-    console.log(chalk.dim(`    ${icons.bullet} ${title}`));
-}
-// Success/Error/Warning messages
-export function printSuccess(message) {
-    console.log(`  ${icons.success} ${chalk.green(message)}`);
-}
-export function printError(message, details) {
-    console.log(`  ${icons.error} ${chalk.red(message)}`);
-    if (details) {
-        console.log(chalk.dim(`    ${details}`));
-    }
-}
-export function printWarning(message) {
-    console.log(`  ${icons.warning} ${chalk.yellow(message)}`);
-}
-export function printInfo(message) {
-    console.log(`  ${icons.info} ${chalk.blue(message)}`);
-}
-// Key-value pairs
-export function printKeyValue(key, value, keyColor = chalk.gray) {
-    console.log(`    ${keyColor(key.padEnd(20))} ${chalk.white(value)}`);
-}
-// Table creation
-export function createTable(headers) {
-    return new Table({
-        head: headers.map(h => chalk.bold(chalk.cyan(h))),
-        style: {
-            head: [],
-            border: [chalk.dim('gray')],
-        },
-        chars: {
-            top: '─',
-            'top-mid': '┬',
-            'top-left': '┌',
-            'top-right': '┐',
-            bottom: '─',
-            'bottom-mid': '┴',
-            'bottom-left': '└',
-            'bottom-right': '┘',
-            left: '│',
-            'left-mid': '├',
-            mid: '─',
-            'mid-mid': '┼',
-            right: '│',
-            'right-mid': '┤',
-            middle: '│',
-        },
-    });
-}
-// Interactive prompts wrapper
-export async function confirm(message, initial = true) {
-    const response = await prompts({
-        type: 'confirm',
-        name: 'value',
-        message: chalk.cyan(message),
-        initial,
-    });
-    return response.value ?? false;
-}
-export async function select(message, choices) {
-    const response = await prompts({
-        type: 'select',
-        name: 'value',
-        message: chalk.cyan(message),
-        choices: choices.map(c => ({
-            title: c.title,
-            value: c.value,
-            description: c.description,
-        })),
-    });
-    return response.value ?? null;
-}
-export async function input(message, initial, validate) {
-    const response = await prompts({
-        type: 'text',
-        name: 'value',
-        message: chalk.cyan(message),
-        initial,
-        validate,
-    });
-    return response.value ?? null;
-}
-export async function password(message) {
-    const response = await prompts({
-        type: 'password',
-        name: 'value',
-        message: chalk.cyan(message),
-    });
-    return response.value ?? null;
-}
-// Progress bar for file operations
-export function printProgress(current, total, prefix = 'Progress') {
-    const percentage = Math.round((current / total) * 100);
-    const filled = Math.round((current / total) * 20);
-    const empty = 20 - filled;
-    const bar = chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
-    process.stdout.write(`\r  ${chalk.cyan(prefix)} ${bar} ${chalk.white(`${percentage}%`)} (${current}/${total})`);
-    if (current === total) {
-        process.stdout.write('\n');
-    }
-}
-// Box drawing
-export function printBox(title, lines) {
-    const maxLength = Math.max(title.length, ...lines.map(l => l.length));
-    const width = maxLength + 4;
-    console.log(chalk.cyan('  ┌' + '─'.repeat(width - 2) + '┐'));
-    console.log(chalk.cyan(`  │ ${chalk.bold(title).padEnd(width - 3)}│`));
-    console.log(chalk.cyan('  ├' + '─'.repeat(width - 2) + '┤'));
-    lines.forEach(line => {
-        console.log(chalk.cyan(`  │ ${line.padEnd(width - 3)}│`));
-    });
-    console.log(chalk.cyan('  └' + '─'.repeat(width - 2) + '┘'));
-}
-// Format bytes
-export function formatBytes(bytes) {
-    if (bytes === 0)
-        return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-}
-// Format duration
-export function formatDuration(ms) {
-    if (ms < 1000)
-        return `${ms}ms`;
-    if (ms < 60000)
-        return `${(ms / 1000).toFixed(1)}s`;
-    return `${(ms / 60000).toFixed(1)}m`;
-}
-// Command hint
-export function printCommandHint(command, description) {
-    console.log(`    ${chalk.dim('$')} ${chalk.cyan(command)} ${chalk.gray(description)}`);
-}
-// Divider
-export function printDivider() {
-    console.log(chalk.dim('  ' + '─'.repeat(60)));
-}
-// Welcome message
-export function printWelcome() {
-    console.log();
-    console.log(chalk.cyan('  ╭──────────────────────────────────────────────╮'));
-    console.log(chalk.cyan('  │') + '  ' + chalk.bold(chalk.magenta('🚀 Delta CLI')) + chalk.dim(' - Code Analysis & Documentation   ') + chalk.cyan('│'));
-    console.log(chalk.cyan('  ├──────────────────────────────────────────────┤'));
-    console.log(chalk.cyan('  │') + '  ' + chalk.gray('Local-first analysis with cloud power        ') + chalk.cyan('│'));
-    console.log(chalk.cyan('  ╰──────────────────────────────────────────────╯'));
-    console.log();
-}
-//# sourceMappingURL=ui.js.map

package/dist/apps/cli/src/welcome.js

@@ -1,81 +0,0 @@
-#!/usr/bin/env node
-import gradient from 'gradient-string';
-import figlet from 'figlet';
-import updateNotifier from 'update-notifier';
-import chalk from 'chalk';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-// Read package.json for version info
-const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
-// Check for updates
-const notifier = updateNotifier({
-    pkg,
-    updateCheckInterval: 1000 * 60 * 60 // 1 hour
-});
-// Define gradient themes
-export const gradients = {
-    delta: gradient(['#00d4ff', '#7b2cbf', '#ff006e']),
-    cyber: gradient(['#00f5ff', '#0080ff', '#8000ff']),
-    sunset: gradient(['#ff4e50', '#fca311', '#e85d04']),
-    neon: gradient(['#39ff14', '#00ffff', '#ff00ff']),
-    ocean: gradient(['#0066ff', '#00ccff', '#66ffff']),
-    fire: gradient(['#ff4e00', '#ff9500', '#ffcc00']),
-};
-// Print animated logo
-export function printLogo(variant = 'delta') {
-    const text = figlet.textSync('DELTA', {
-        font: 'Big Money-nw',
-        horizontalLayout: 'default',
-        verticalLayout: 'default',
-    });
-    console.log('\n' + gradients[variant](text) + '\n');
-}
-// Print minimal logo
-export function printMinimalLogo() {
-    const text = figlet.textSync('Δ', {
-        font: 'ANSI Shadow',
-        horizontalLayout: 'default',
-    });
-    console.log(gradients.delta(text));
-}
-// Print welcome screen
-export function printWelcome() {
-    console.clear();
-    printLogo();
-    console.log(chalk.dim('  ═══════════════════════════════════════════════════════════════'));
-    console.log();
-    console.log(chalk.white.bold('  🚀 Delta CLI v2.0') + chalk.gray(' — Next-gen code analysis & documentation'));
-    console.log();
-    console.log(chalk.gray('  Local-first architecture with ') + chalk.cyan('cloud power') + chalk.gray(' & ') + chalk.magenta('AI intelligence'));
-    console.log();
-    console.log(chalk.dim('  ═══════════════════════════════════════════════════════════════'));
-    console.log();
-    // Update notification
-    if (notifier.update) {
-        console.log(chalk.yellow.bold('  ⚡ Update Available!'));
-        console.log(chalk.gray(`     ${notifier.update.current} → ${notifier.update.latest}`));
-        console.log(chalk.cyan(`     Run: npm install -g ${pkg.name}`));
-        console.log();
-    }
-}
-// Print tips
-export function printTips() {
-    const tips = [
-        { cmd: 'delta login', desc: 'Authenticate with your account' },
-        { cmd: 'delta analyze', desc: 'Run code analysis on current project' },
-        { cmd: 'delta dashboard', desc: 'Open interactive dashboard' },
-        { cmd: 'delta --help', desc: 'Show all available commands' },
-    ];
-    console.log(chalk.bold.cyan('  Quick Start:'));
-    console.log();
-    tips.forEach(({ cmd, desc }) => {
-        console.log(chalk.gray('    • ') + chalk.cyan(cmd) + chalk.gray(` — ${desc}`));
-    });
-    console.log();
-    console.log(chalk.dim('  Press ') + chalk.bold('Ctrl+T') + chalk.dim(' for variants • ') + chalk.bold('Tab') + chalk.dim(' for agents • ') + chalk.bold('Ctrl+P') + chalk.dim(' for commands'));
-    console.log();
-}
-//# sourceMappingURL=welcome.js.map

package/dist/auth/secure-auth.js

@@ -1,372 +0,0 @@
-/**
- * Secure Authentication System with OAuth2 + Keychain Integration
- * Features:
- * - OAuth2 PKCE flow
- * - Secure token storage in OS keychain
- * - Automatic token refresh
- * - Session management
- * - PAT (Personal Access Token) support for CI/CD
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import fetch from 'node-fetch';
-import open from 'open';
-import { createServer } from 'http';
-import { URL } from 'url';
-import crypto from 'crypto';
-import chalk from 'chalk';
-import { printSuccess, printError, printInfo, printWarning, startSpinner, stopSpinner } from '../ui.js';
-const CONFIG_DIR = path.join(os.homedir(), '.delta');
-const TOKEN_FILE = path.join(CONFIG_DIR, 'tokens.enc');
-const KEY_FILE = path.join(CONFIG_DIR, '.key');
-// Derive encryption key from machine-specific data
-async function getEncryptionKey() {
-    try {
-        const keyData = await fs.readFile(KEY_FILE, 'utf-8').catch(() => null);
-        if (keyData) {
-            return Buffer.from(keyData, 'hex');
-        }
-    }
-    catch {
-        // File doesn't exist, generate new key
-    }
-    const machineId = `${os.userInfo().username}@${os.hostname()}`;
-    const salt = 'delta-cli-v2-fixed-salt';
-    const key = crypto.pbkdf2Sync(machineId, salt, 100000, 32, 'sha256');
-    await fs.mkdir(CONFIG_DIR, { recursive: true });
-    await fs.writeFile(KEY_FILE, key.toString('hex'), { mode: 0o600 });
-    return key;
-}
-// Encrypt data
-async function encrypt(data) {
-    const key = await getEncryptionKey();
-    const iv = crypto.randomBytes(16);
-    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
-    let encrypted = cipher.update(data, 'utf-8', 'hex');
-    encrypted += cipher.final('hex');
-    const authTag = cipher.getAuthTag();
-    return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
-}
-// Decrypt data
-async function decrypt(encryptedData) {
-    try {
-        const key = await getEncryptionKey();
-        const parts = encryptedData.split(':');
-        if (parts.length !== 3)
-            return null;
-        const iv = Buffer.from(parts[0], 'hex');
-        const authTag = Buffer.from(parts[1], 'hex');
-        const encrypted = parts[2];
-        const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
-        decipher.setAuthTag(authTag);
-        let decrypted = decipher.update(encrypted, 'hex', 'utf-8');
-        decrypted += decipher.final('utf-8');
-        return decrypted;
-    }
-    catch {
-        return null;
-    }
-}
-// PKCE Code Generator
-function generatePKCE() {
-    const verifier = crypto.randomBytes(32).toString('base64url');
-    const challenge = crypto
-        .createHash('sha256')
-        .update(verifier)
-        .digest('base64url');
-    return { verifier, challenge };
-}
-// Secure Token Storage using encrypted file
-export class SecureTokenStore {
-    static async saveTokens(tokens) {
-        await fs.mkdir(CONFIG_DIR, { recursive: true });
-        const data = JSON.stringify({
-            access: tokens.access || null,
-            refresh: tokens.refresh || null,
-            updatedAt: new Date().toISOString(),
-        });
-        const encrypted = await encrypt(data);
-        await fs.writeFile(TOKEN_FILE, encrypted, { mode: 0o600 });
-    }
-    static async loadTokens() {
-        try {
-            const encrypted = await fs.readFile(TOKEN_FILE, 'utf-8');
-            const decrypted = await decrypt(encrypted);
-            if (!decrypted)
-                return { access: null, refresh: null };
-            const data = JSON.parse(decrypted);
-            return {
-                access: data.access || null,
-                refresh: data.refresh || null,
-            };
-        }
-        catch {
-            return { access: null, refresh: null };
-        }
-    }
-    static async saveAccessToken(token) {
-        const tokens = await this.loadTokens();
-        await this.saveTokens({ access: token, refresh: tokens.refresh ?? undefined });
-    }
-    static async getAccessToken() {
-        const tokens = await this.loadTokens();
-        return tokens.access;
-    }
-    static async saveRefreshToken(token) {
-        const tokens = await this.loadTokens();
-        await this.saveTokens({ refresh: token, access: tokens.access ?? undefined });
-    }
-    static async getRefreshToken() {
-        const tokens = await this.loadTokens();
-        return tokens.refresh;
-    }
-    static async clearTokens() {
-        try {
-            await fs.unlink(TOKEN_FILE);
-        }
-        catch {
-            // File may not exist
-        }
-    }
-    static async hasTokens() {
-        const token = await this.getAccessToken();
-        return !!token;
-    }
-}
-// OAuth2 Flow Handler - Uses configurable API URL for local development
-export async function startOAuthFlow(method = 'oauth') {
-    startSpinner('Starting OAuth2 authentication flow...');
-    try {
-        // Get API URL from environment or use default
-        const apiUrl = process.env.DELTA_API_URL || 'http://localhost:3000';
-        const { verifier, challenge } = generatePKCE();
-        const state = crypto.randomBytes(16).toString('hex');
-        // Start local server FIRST to capture callback and get actual port
-        const { authCode, redirectUri } = await new Promise((resolve, reject) => {
-            const server = createServer(async (req, res) => {
-                const url = new URL(req.url || '/', `http://localhost:${redirectPort}`);
-                if (url.pathname === '/callback') {
-                    const code = url.searchParams.get('code');
-                    const returnedState = url.searchParams.get('state');
-                    const error = url.searchParams.get('error');
-                    if (error) {
-                        res.writeHead(400, { 'Content-Type': 'text/html' });
-                        res.end(`<html><body><h1>❌ Authentication Failed</h1><p>${error}</p></body></html>`);
-                        reject(new Error(error));
-                        server.close();
-                        return;
-                    }
-                    if (!code || returnedState !== state) {
-                        res.writeHead(400, { 'Content-Type': 'text/html' });
-                        res.end(`<html><body><h1>❌ Invalid Response</h1></body></html>`);
-                        reject(new Error('Invalid OAuth response'));
-                        server.close();
-                        return;
-                    }
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
-                    res.end(`<html><body style="text-align:center;padding:50px;"><h1>✓ Successfully Signed In!</h1><p>You can close this window.</p></body></html>`);
-                    const address = server.address();
-                    const actualPort = typeof address === 'object' && address ? address.port : 3456;
-                    resolve({ authCode: code, redirectUri: `http://localhost:${actualPort}/callback` });
-                    server.close();
-                }
-            });
-            let redirectPort = 3456;
-            // Try to listen on port 3456
-            server.listen(3456, '127.0.0.1', () => {
-                console.log(chalk.dim(`  Waiting for authentication on port ${redirectPort}...`));
-            });
-            // Handle port in use error by trying random port
-            server.on('error', (err) => {
-                if (err.code === 'EADDRINUSE') {
-                    printWarning('Port 3456 is busy, trying alternative port...');
-                    redirectPort = 0; // Let OS assign
-                    server.listen(0, '127.0.0.1', () => {
-                        const address = server.address();
-                        const actualPort = typeof address === 'object' && address ? address.port : 3456;
-                        redirectPort = actualPort;
-                        console.log(chalk.dim(`  Waiting for authentication on port ${actualPort}...`));
-                    });
-                }
-                else {
-                    reject(err);
-                }
-            });
-            // Timeout after 5 minutes
-            setTimeout(() => {
-                server.close();
-                reject(new Error('Authentication timeout'));
-            }, 5 * 60 * 1000);
-        });
-        // NOW build OAuth URL with correct redirect_uri
-        const oauthUrl = new URL(`${apiUrl}/api/auth/authorize`);
-        oauthUrl.searchParams.set('response_type', 'code');
-        oauthUrl.searchParams.set('client_id', 'delta-cli');
-        oauthUrl.searchParams.set('redirect_uri', redirectUri);
-        oauthUrl.searchParams.set('code_challenge', challenge);
-        oauthUrl.searchParams.set('code_challenge_method', 'S256');
-        oauthUrl.searchParams.set('state', state);
-        oauthUrl.searchParams.set('scope', 'read write analyze');
-        if (method === 'github') {
-            oauthUrl.searchParams.set('provider', 'github');
-        }
-        else if (method === 'google') {
-            oauthUrl.searchParams.set('provider', 'google');
-        }
-        stopSpinner(true, 'OAuth server ready');
-        // Open browser with correct URL
-        printInfo(`Opening browser for authentication...`);
-        printInfo(`Full URL: ${oauthUrl.toString()}`);
-        await open(oauthUrl.toString());
-        // Wait for authCode (already resolved above)
-        // Exchange code for tokens
-        startSpinner('Exchanging authorization code...');
-        const tokenResponse = await fetch(`${apiUrl}/api/auth/token`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                grant_type: 'authorization_code',
-                code: authCode,
-                redirect_uri: redirectUri,
-                client_id: 'delta-cli',
-                code_verifier: verifier,
-            }),
-        });
-        if (!tokenResponse.ok) {
-            throw new Error('Failed to exchange authorization code');
-        }
-        const tokens = await tokenResponse.json();
-        // Store tokens securely
-        await SecureTokenStore.saveAccessToken(tokens.access_token);
-        await SecureTokenStore.saveRefreshToken(tokens.refresh_token);
-        stopSpinner(true, 'Authentication successful!');
-        printSuccess('Successfully authenticated with Delta Cloud');
-        printInfo(`Token expires in ${tokens.expires_in} seconds`);
-        return true;
-    }
-    catch (error) {
-        stopSpinner(false, 'Authentication failed');
-        printError('OAuth2 authentication failed', error.message);
-        return false;
-    }
-}
-// PAT Authentication for CI/CD - Uses configurable API URL
-export async function authenticateWithPAT(token) {
-    startSpinner('Validating Personal Access Token...');
-    try {
-        const apiUrl = process.env.DELTA_API_URL || 'http://localhost:3000';
-        // Validate token
-        const response = await fetch(`${apiUrl}/api/auth/verify`, {
-            headers: {
-                'Authorization': `Bearer ${token}`,
-            },
-        });
-        if (!response.ok) {
-            throw new Error('Invalid token');
-        }
-        const data = await response.json();
-        // Store token
-        await SecureTokenStore.saveAccessToken(token);
-        stopSpinner(true, 'Token validated');
-        printSuccess(`Authenticated as ${data.user.email}`);
-        return true;
-    }
-    catch (error) {
-        stopSpinner(false, 'Token validation failed');
-        printError('PAT authentication failed', error.message);
-        return false;
-    }
-}
-// Token Refresh - Uses configurable API URL
-export async function refreshAccessToken() {
-    const refreshToken = await SecureTokenStore.getRefreshToken();
-    if (!refreshToken) {
-        printError('No refresh token available');
-        return false;
-    }
-    try {
-        const apiUrl = process.env.DELTA_API_URL || 'http://localhost:3000';
-        const response = await fetch(`${apiUrl}/api/auth/refresh`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                grant_type: 'refresh_token',
-                refresh_token: refreshToken,
-                client_id: 'delta-cli',
-            }),
-        });
-        if (!response.ok) {
-            throw new Error('Token refresh failed');
-        }
-        const tokens = await response.json();
-        await SecureTokenStore.saveAccessToken(tokens.access_token);
-        if (tokens.refresh_token) {
-            await SecureTokenStore.saveRefreshToken(tokens.refresh_token);
-        }
-        return true;
-    }
-    catch (error) {
-        printError('Failed to refresh token', error.message);
-        return false;
-    }
-}
-// Logout
-export async function logout() {
-    startSpinner('Clearing credentials...');
-    try {
-        await SecureTokenStore.clearTokens();
-        stopSpinner(true, 'Logged out');
-        printSuccess('Successfully logged out');
-    }
-    catch (error) {
-        stopSpinner(false, 'Logout failed');
-        printError('Failed to clear credentials', error.message);
-    }
-}
-// Auth Status - Uses configurable API URL
-export async function getAuthStatus() {
-    const token = await SecureTokenStore.getAccessToken();
-    if (!token) {
-        return { authenticated: false };
-    }
-    try {
-        const apiUrl = process.env.DELTA_API_URL || 'http://localhost:3000';
-        const response = await fetch(`${apiUrl}/api/auth/me`, {
-            headers: {
-                'Authorization': `Bearer ${token}`,
-            },
-        });
-        if (!response.ok) {
-            // Try to refresh token
-            const refreshed = await refreshAccessToken();
-            if (!refreshed) {
-                return { authenticated: false };
-            }
-            // Retry with new token
-            const newToken = await SecureTokenStore.getAccessToken();
-            const retryResponse = await fetch(`${apiUrl}/api/auth/me`, {
-                headers: {
-                    'Authorization': `Bearer ${newToken}`,
-                },
-            });
-            if (!retryResponse.ok) {
-                return { authenticated: false };
-            }
-            const userData = await retryResponse.json();
-            return {
-                authenticated: true,
-                user: userData,
-            };
-        }
-        const userData = await response.json();
-        return {
-            authenticated: true,
-            user: userData,
-        };
-    }
-    catch {
-        return { authenticated: false };
-    }
-}
-//# sourceMappingURL=secure-auth.js.map