langctl 0.0.1 → 0.1.0

package/dist/auth.d.ts

@@ -0,0 +1,33 @@
+export interface ApiKeyData {
+    organization_id: string;
+    organization: {
+        id: string;
+        name: string;
+        plan: string;
+    };
+}
+/**
+ * Verify API key via Edge Function
+ */
+export declare function verifyApiKey(plainTextKey: string): Promise<ApiKeyData | null>;
+/**
+ * Authenticate and save credentials to config
+ */
+export declare function authenticate(apiKey: string): Promise<{
+    success: boolean;
+    message: string;
+    data?: ApiKeyData;
+}>;
+/**
+ * Check if user is authenticated
+ */
+export declare function isAuthenticated(): boolean;
+/**
+ * Get current organization ID
+ */
+export declare function getOrganizationId(): string | undefined;
+/**
+ * Logout (clear authentication)
+ */
+export declare function logout(): void;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.js

@@ -0,0 +1,106 @@
+import { config } from './config.js';
+// Edge Function URL
+const EDGE_FUNCTION_URL = 'https://bcgnmvkgkbhbxzzflwdb.supabase.co/functions/v1/verify-api-key';
+// Normalize and validate API key input
+function sanitizeApiKey(input) {
+    const raw = (input || '').trim().toLowerCase();
+    if (!raw.startsWith('lc_')) {
+        return { ok: false, message: 'API key must start with lc_' };
+    }
+    const hex = raw.slice(3); // after lc_
+    const hexOnly = hex.replace(/[^a-f0-9]/g, '');
+    if (hexOnly.length !== 64) {
+        return { ok: false, message: 'Invalid API key format. Expected lc_ followed by 64 hex characters' };
+    }
+    return { ok: true, key: `lc_${hexOnly}` };
+}
+/**
+ * Verify API key via Edge Function
+ */
+export async function verifyApiKey(plainTextKey) {
+    try {
+        const sanitized = sanitizeApiKey(plainTextKey);
+        if (!sanitized.ok || !sanitized.key) {
+            return null;
+        }
+        // Call Edge Function
+        const response = await fetch(EDGE_FUNCTION_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ apiKey: sanitized.key })
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = await response.json();
+        if (!data.success) {
+            return null;
+        }
+        // Map Edge Function response to ApiKeyData format
+        return {
+            organization_id: data.organizationId,
+            organization: {
+                id: data.organizationId,
+                name: data.organizationName,
+                plan: data.plan
+            }
+        };
+    }
+    catch (error) {
+        console.error('Error verifying API key:', error);
+        return null;
+    }
+}
+/**
+ * Authenticate and save credentials to config
+ */
+export async function authenticate(apiKey) {
+    const sanitized = sanitizeApiKey(apiKey);
+    if (!sanitized.ok || !sanitized.key) {
+        return {
+            success: false,
+            message: sanitized.message || 'Invalid API key format. Expected format: lc_[64 hex characters]'
+        };
+    }
+    // Verify via Edge Function
+    const keyData = await verifyApiKey(sanitized.key);
+    if (!keyData) {
+        return {
+            success: false,
+            message: 'Invalid or revoked API key. Please check your key and try again.'
+        };
+    }
+    // Save to config
+    config.set('apiKey', sanitized.key);
+    config.set('organizationId', keyData.organization_id);
+    config.set('organizationName', keyData.organization.name);
+    return {
+        success: true,
+        message: `Successfully authenticated as ${keyData.organization.name}`,
+        data: keyData
+    };
+}
+/**
+ * Check if user is authenticated
+ */
+export function isAuthenticated() {
+    return !!(config.get('apiKey') && config.get('organizationId'));
+}
+/**
+ * Get current organization ID
+ */
+export function getOrganizationId() {
+    return config.get('organizationId');
+}
+/**
+ * Logout (clear authentication)
+ */
+export function logout() {
+    config.delete('apiKey');
+    config.delete('organizationId');
+    config.delete('organizationName');
+    config.delete('defaultProject');
+}
+//# sourceMappingURL=auth.js.map

package/dist/commands/auth.d.ts

@@ -0,0 +1,3 @@
+export declare function authCommand(apiKey: string): Promise<void>;
+export declare function logoutCommand(): Promise<void>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/commands/auth.js

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { authenticate, logout } from '../auth.js';
+import { config } from '../config.js';
+import { initializeSupabase } from '../supabase.js';
+// Hardcoded Supabase credentials
+const SUPABASE_URL = 'https://bcgnmvkgkbhbxzzflwdb.supabase.co';
+const SUPABASE_ANON_KEY = 'sb_publishable_WCpKr-NwubrPtOj2E0cvAQ_TzvfXsNB';
+export async function authCommand(apiKey) {
+    // Ensure Supabase is configured
+    if (!config.get('supabaseUrl')) {
+        config.set('supabaseUrl', SUPABASE_URL);
+        config.set('supabaseAnonKey', SUPABASE_ANON_KEY);
+    }
+    // Initialize Supabase
+    try {
+        initializeSupabase();
+    }
+    catch (error) {
+        console.log(chalk.red('✗ Failed to connect to Langctl servers.\n'));
+        return;
+    }
+    const spinner = ora('Authenticating...').start();
+    const result = await authenticate(apiKey);
+    if (result.success) {
+        spinner.succeed(chalk.green(`Authenticated as ${result.data?.organization.name}`));
+        console.log(chalk.gray(`\nAPI Key saved to: ${config.getConfigPath()}\n`));
+    }
+    else {
+        spinner.fail(chalk.red(result.message));
+        console.log(chalk.yellow('\nTroubleshooting:'));
+        console.log(chalk.white('  - Check that your API key is correct'));
+        console.log(chalk.white('  - Verify the key is not revoked in the dashboard'));
+        console.log(chalk.white('  - Generate a new key: https://langctl.com/dashboard/settings/api-keys\n'));
+    }
+}
+export async function logoutCommand() {
+    logout();
+    console.log(chalk.green('✓ Logged out successfully\n'));
+}
+//# sourceMappingURL=auth.js.map

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+export declare function configCommand(): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/commands/config.js

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import { config } from '../config.js';
+export function configCommand() {
+    console.log(chalk.blue.bold('\n📋 Langctl Configuration\n'));
+    const allConfig = config.getAll();
+    if (Object.keys(allConfig).length === 0) {
+        console.log(chalk.yellow('No configuration found. Run "langctl init" to set up.\n'));
+        return;
+    }
+    // Display config with masked sensitive values
+    const displayConfig = {
+        ...allConfig,
+        apiKey: allConfig.apiKey ? maskApiKey(allConfig.apiKey) : undefined,
+        supabaseAnonKey: allConfig.supabaseAnonKey ? maskSensitive(allConfig.supabaseAnonKey) : undefined
+    };
+    Object.entries(displayConfig).forEach(([key, value]) => {
+        if (value !== undefined) {
+            console.log(chalk.white(`${key}: ${chalk.cyan(value)}`));
+        }
+    });
+    console.log(chalk.gray(`\nConfig file: ${config.getConfigPath()}\n`));
+}
+function maskApiKey(key) {
+    if (key.length < 10)
+        return '***';
+    return `${key.substring(0, 10)}...${key.substring(key.length - 4)}`;
+}
+function maskSensitive(value) {
+    if (value.length < 8)
+        return '***';
+    return `${value.substring(0, 8)}...`;
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/debug.d.ts

@@ -0,0 +1,3 @@
+export declare function debugListApiKeys(): Promise<void>;
+export declare function debugListOrganizations(): Promise<void>;
+//# sourceMappingURL=debug.d.ts.map

package/dist/commands/debug.js

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getSupabase, initializeSupabase } from '../supabase.js';
+import { config } from '../config.js';
+export async function debugListApiKeys() {
+    // Ensure supabase is initialized
+    const url = config.get('supabaseUrl');
+    const key = config.get('supabaseAnonKey');
+    try {
+        initializeSupabase(url, key);
+    }
+    catch (e) {
+        console.error(chalk.red('✗ Supabase not initialized. Run "langctl init" first.'));
+        return;
+    }
+    const supabase = getSupabase();
+    const spinner = ora('Fetching API keys (debug)...').start();
+    const { data, error } = await supabase
+        .from('api_keys')
+        .select('id, name, key_prefix, organization_id, revoked, created_at, last_used_at')
+        .limit(100);
+    if (error) {
+        spinner.fail(chalk.red(`Error fetching API keys: ${error.message}`));
+        console.log(chalk.yellow('Hint: Check that the anon key has SELECT access to api_keys in this project.'));
+        return;
+    }
+    spinner.succeed(chalk.green(`Found ${data?.length || 0} API keys`));
+    if (!data || data.length === 0) {
+        console.log(chalk.yellow('No API keys visible with current Supabase credentials.'));
+        console.log(chalk.white(`Supabase URL: ${url}`));
+        console.log(chalk.white(`Anon key prefix: ${(key || '').substring(0, 12)}...`));
+        return;
+    }
+    for (const row of data) {
+        console.log(`${chalk.cyan(row.id)}  ${chalk.white(row.name)}  prefix=${chalk.magenta(row.key_prefix)}  org=${chalk.yellow(row.organization_id)}  revoked=${row.revoked ? chalk.red('true') : chalk.green('false')}  last_used=${chalk.gray(row.last_used_at || 'never')}`);
+    }
+}
+export async function debugListOrganizations() {
+    const url = config.get('supabaseUrl');
+    const key = config.get('supabaseAnonKey');
+    try {
+        initializeSupabase(url, key);
+    }
+    catch (e) {
+        console.error(chalk.red('✗ Supabase not initialized. Run "langctl init" first.'));
+        return;
+    }
+    const supabase = getSupabase();
+    const spinner = ora('Fetching organizations (debug)...').start();
+    const { data, error } = await supabase
+        .from('organizations')
+        .select('id, name, plan, created_at')
+        .limit(100);
+    if (error) {
+        spinner.fail(chalk.red(`Error fetching organizations: ${error.message}`));
+        return;
+    }
+    spinner.succeed(chalk.green(`Found ${data?.length || 0} organizations`));
+    (data || []).forEach(o => {
+        console.log(`${chalk.cyan(o.id)}  ${chalk.white(o.name)}  plan=${chalk.magenta(o.plan)}  created=${chalk.gray(o.created_at)}`);
+    });
+}
+//# sourceMappingURL=debug.js.map

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+export declare function initCommand(): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.js

@@ -0,0 +1,93 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { config } from '../config.js';
+import { authenticate } from '../auth.js';
+import { initializeSupabase } from '../supabase.js';
+import { showLogo } from '../utils/banner.js';
+// Hardcoded Supabase credentials - users don't need to know about our backend
+const SUPABASE_URL = 'https://bcgnmvkgkbhbxzzflwdb.supabase.co';
+const SUPABASE_ANON_KEY = 'sb_publishable_WCpKr-NwubrPtOj2E0cvAQ_TzvfXsNB';
+export async function initCommand() {
+    // Show logo
+    showLogo();
+    console.log(chalk.blue.bold('🚀 CLI Setup\n'));
+    console.log(chalk.gray('Get your API key from: https://app.langctl.com/dashboard/settings/api-keys\n'));
+    // Check if already configured
+    if (config.isConfigured()) {
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Configuration already exists. Do you want to reconfigure?',
+                default: false
+            }
+        ]);
+        if (!confirm) {
+            console.log(chalk.yellow('\nSetup cancelled.'));
+            return;
+        }
+    }
+    // Automatically save Supabase credentials (user doesn't need to know)
+    config.set('supabaseUrl', SUPABASE_URL);
+    config.set('supabaseAnonKey', SUPABASE_ANON_KEY);
+    // Initialize Supabase client
+    try {
+        initializeSupabase(SUPABASE_URL, SUPABASE_ANON_KEY);
+    }
+    catch (error) {
+        console.error(chalk.red('✗ Failed to connect to Langctl servers'));
+        console.error(chalk.red('Please check your internet connection and try again.\n'));
+        return;
+    }
+    // Ask for API key
+    const { apiKey } = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'apiKey',
+            message: 'Enter your API key:',
+            mask: '*',
+            filter: (input) => input?.trim(),
+            validate: (input) => {
+                const value = (input || '').trim();
+                if (!value || !value.startsWith('lc_')) {
+                    return 'Please enter a valid API key (starts with lc_)';
+                }
+                if (value.length !== 67) {
+                    return 'Invalid API key format (should be 67 characters)';
+                }
+                return true;
+            }
+        }
+    ]);
+    // Authenticate
+    const spinner = ora('Verifying API key...').start();
+    const result = await authenticate(apiKey);
+    if (result.success) {
+        spinner.succeed(chalk.green(`Authenticated as ${result.data?.organization.name}`));
+    }
+    else {
+        spinner.fail(chalk.red(result.message));
+        console.log(chalk.yellow('\nTroubleshooting:'));
+        console.log(chalk.white('  - Check that your API key is correct'));
+        console.log(chalk.white('  - Verify the key is not revoked in the dashboard'));
+        console.log(chalk.white('  - Generate a new key if needed: https://app.langctl.com/dashboard/settings/api-keys\n'));
+        return;
+    }
+    // Ask for default settings
+    const { defaultLanguage } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'defaultLanguage',
+            message: 'Default language code:',
+            default: 'en'
+        }
+    ]);
+    config.set('defaultLanguage', defaultLanguage);
+    console.log(chalk.green.bold('\n✓ Setup complete!\n'));
+    console.log(chalk.gray(`Configuration saved to: ${config.getConfigPath()}\n`));
+    console.log(chalk.blue('Next steps:'));
+    console.log(chalk.white('  1. Run "langctl projects list" to see your projects'));
+    console.log(chalk.white('  2. Run "langctl pull <project-slug>" to download translations\n'));
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/projects.d.ts

@@ -0,0 +1,2 @@
+export declare function projectsListCommand(): Promise<void>;
+//# sourceMappingURL=projects.d.ts.map

package/dist/commands/projects.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getSupabase } from '../supabase.js';
+import { isAuthenticated, getOrganizationId } from '../auth.js';
+export async function projectsListCommand() {
+    // Check authentication
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        return;
+    }
+    const organizationId = getOrganizationId();
+    if (!organizationId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl init" again.\n'));
+        return;
+    }
+    const spinner = ora('Fetching projects...').start();
+    try {
+        const supabase = getSupabase();
+        const { data, error } = await supabase
+            .from('projects')
+            .select('*')
+            .eq('organization_id', organizationId)
+            .is('deleted_at', null)
+            .order('created_at', { ascending: false });
+        if (error) {
+            spinner.fail(chalk.red('Failed to fetch projects'));
+            console.error(chalk.red(`Error: ${error.message}\n`));
+            return;
+        }
+        spinner.stop();
+        if (!data || data.length === 0) {
+            console.log(chalk.yellow('\nNo projects found. Create one in the dashboard first.\n'));
+            return;
+        }
+        console.log(chalk.blue.bold(`\n📦 Projects (${data.length})\n`));
+        data.forEach((project) => {
+            console.log(chalk.white.bold(project.name));
+            console.log(chalk.gray(`  Slug: ${project.slug}`));
+            if (project.description) {
+                console.log(chalk.gray(`  Description: ${project.description}`));
+            }
+            console.log(chalk.gray(`  Languages: ${project.languages.join(', ')}`));
+            console.log(chalk.gray(`  Default: ${project.default_language}`));
+            console.log('');
+        });
+        console.log(chalk.blue('To pull translations, run:'));
+        console.log(chalk.white(`  langctl pull ${data[0].slug}\n`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to fetch projects'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+    }
+}
+//# sourceMappingURL=projects.js.map

package/dist/commands/pull.d.ts

@@ -0,0 +1,9 @@
+export interface PullOptions {
+    language?: string;
+    format?: string;
+    output?: string;
+    dir?: string;
+    publishedOnly?: boolean;
+}
+export declare function pullCommand(projectIdentifier: string, options: PullOptions): Promise<void>;
+//# sourceMappingURL=pull.d.ts.map

package/dist/commands/pull.js

@@ -0,0 +1,194 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { writeFileSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { getSupabase } from '../supabase.js';
+import { isAuthenticated, getOrganizationId } from '../auth.js';
+import { exportTranslations } from '../exporters/index.js';
+/**
+ * Get platform-specific output directory
+ */
+function getPlatformDirectory(format) {
+    const platformDirs = {
+        'json': 'i18n',
+        'json-nested': 'i18n',
+        'ios': 'ios',
+        'android': 'android',
+        'flutter': 'flutter'
+    };
+    return platformDirs[format] || 'i18n';
+}
+/**
+ * Resolve project identifier (name, slug, or UUID) to project UUID
+ */
+async function resolveProjectId(identifier, organizationId) {
+    const supabase = getSupabase();
+    // Check if it's already a UUID (format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (uuidRegex.test(identifier)) {
+        // Verify it exists
+        const { data } = await supabase
+            .from('projects')
+            .select('id')
+            .eq('id', identifier)
+            .eq('organization_id', organizationId)
+            .is('deleted_at', null)
+            .single();
+        return data ? identifier : null;
+    }
+    // Try to match by slug (case-insensitive)
+    const { data: bySlug } = await supabase
+        .from('projects')
+        .select('id')
+        .eq('organization_id', organizationId)
+        .ilike('slug', identifier)
+        .is('deleted_at', null)
+        .single();
+    if (bySlug) {
+        return bySlug.id;
+    }
+    // Try to match by name (case-insensitive)
+    const { data: byName } = await supabase
+        .from('projects')
+        .select('id')
+        .eq('organization_id', organizationId)
+        .ilike('name', identifier)
+        .is('deleted_at', null)
+        .single();
+    if (byName) {
+        return byName.id;
+    }
+    return null;
+}
+export async function pullCommand(projectIdentifier, options) {
+    // Check authentication
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        return;
+    }
+    const organizationId = getOrganizationId();
+    if (!organizationId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl init" again.\n'));
+        return;
+    }
+    // Set defaults
+    const format = (options.format || 'json');
+    const publishedOnly = options.publishedOnly !== false; // Default to true
+    const specificLanguage = options.language; // If not specified, pull all languages
+    const baseDir = options.dir || './translations'; // Default to ./translations
+    // Validate format
+    const validFormats = ['json', 'json-nested', 'ios', 'android', 'flutter'];
+    if (!validFormats.includes(format)) {
+        console.log(chalk.red(`✗ Invalid format: ${format}`));
+        console.log(chalk.yellow(`Valid formats: ${validFormats.join(', ')}\n`));
+        return;
+    }
+    const spinner = ora('Resolving project...').start();
+    try {
+        const supabase = getSupabase();
+        // Resolve project identifier to UUID
+        const projectId = await resolveProjectId(projectIdentifier, organizationId);
+        if (!projectId) {
+            spinner.fail(chalk.red(`Project "${projectIdentifier}" not found`));
+            console.log(chalk.yellow('\nRun "langctl projects list" to see available projects.\n'));
+            return;
+        }
+        // Fetch project details
+        spinner.text = 'Fetching project...';
+        const { data: project, error: projectError } = await supabase
+            .from('projects')
+            .select('id, name, slug, languages, default_language')
+            .eq('id', projectId)
+            .eq('organization_id', organizationId)
+            .is('deleted_at', null)
+            .single();
+        if (projectError || !project) {
+            spinner.fail(chalk.red('Project not found or access denied'));
+            return;
+        }
+        // Determine which languages to pull
+        let languagesToPull;
+        if (specificLanguage) {
+            // Check if specified language exists in project
+            if (!project.languages.includes(specificLanguage)) {
+                spinner.fail(chalk.red(`Language "${specificLanguage}" not found in project`));
+                console.log(chalk.yellow(`Available languages: ${project.languages.join(', ')}\n`));
+                return;
+            }
+            languagesToPull = [specificLanguage];
+        }
+        else {
+            // Pull all languages
+            languagesToPull = project.languages;
+        }
+        spinner.text = `Fetching translations for "${project.name}"...`;
+        // Fetch translation keys
+        let query = supabase
+            .from('translation_keys')
+            .select('key, translations, description, module')
+            .eq('project_id', projectId)
+            .is('deleted_at', null);
+        if (publishedOnly) {
+            query = query.eq('published', true);
+        }
+        const { data: keys, error: keysError } = await query;
+        if (keysError) {
+            spinner.fail(chalk.red('Failed to fetch translations'));
+            console.error(chalk.red(`Error: ${keysError.message}\n`));
+            return;
+        }
+        if (!keys || keys.length === 0) {
+            spinner.fail(chalk.yellow('No translations found'));
+            console.log(chalk.yellow(`\nNo ${publishedOnly ? 'published ' : ''}translations found for this project.\n`));
+            return;
+        }
+        spinner.succeed(chalk.green(`Found ${keys.length} translation keys`));
+        // Get platform directory
+        const platformDir = getPlatformDirectory(format);
+        // Export translations for each language
+        const exportedFiles = [];
+        for (const language of languagesToPull) {
+            spinner.start(`Exporting ${language}...`);
+            const result = exportTranslations(keys, language, format);
+            // Determine output path
+            let outputPath;
+            if (options.output) {
+                // If custom output is specified and multiple languages, append language code
+                if (languagesToPull.length > 1) {
+                    const ext = result.filename.split('.').pop();
+                    const base = options.output.replace(/\.[^.]+$/, '');
+                    outputPath = `${base}-${language}.${ext}`;
+                }
+                else {
+                    outputPath = options.output;
+                }
+            }
+            else {
+                // Default output path: <baseDir>/<platform>/<language>.<ext>
+                const ext = result.filename.split('.').pop();
+                outputPath = join(baseDir, platformDir, `${language}.${ext}`);
+            }
+            // Create directory if it doesn't exist
+            const dir = dirname(outputPath);
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(outputPath, result.content, 'utf-8');
+            exportedFiles.push(outputPath);
+            spinner.succeed(chalk.green(`Exported ${language} → ${outputPath}`));
+        }
+        // Summary
+        console.log(chalk.hex('#10b981').bold('\n📦 Export Summary:'));
+        console.log(chalk.white(`  Project: ${project.name}`));
+        console.log(chalk.white(`  Format: ${format}`));
+        console.log(chalk.white(`  Platform: ${platformDir}`));
+        console.log(chalk.white(`  Output: ${baseDir}`));
+        console.log(chalk.white(`  Keys: ${keys.length}`));
+        console.log(chalk.white(`  Languages: ${languagesToPull.join(', ')}`));
+        console.log(chalk.white(`  Files: ${exportedFiles.length}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to pull translations'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+    }
+}
+//# sourceMappingURL=pull.js.map