langctl 0.1.0 → 0.1.2

package/dist/auth.d.ts

@@ -26,6 +26,10 @@ export declare function isAuthenticated(): boolean;
  * Get current organization ID
  */
 export declare function getOrganizationId(): string | undefined;
+/**
+ * Get current API key
+ */
+export declare function getApiKey(): string | undefined;
 /**
  * Logout (clear authentication)
  */

package/dist/auth.js

@@ -94,6 +94,12 @@ export function isAuthenticated() {
 export function getOrganizationId() {
     return config.get('organizationId');
 }
+/**
+ * Get current API key
+ */
+export function getApiKey() {
+    return config.get('apiKey');
+}
 /**
  * Logout (clear authentication)
  */

package/dist/commands/auth.js

@@ -3,16 +3,8 @@ 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
+    // Initialize Supabase (with hardcoded credentials)
     try {
         initializeSupabase();
     }

package/dist/commands/config.js

@@ -9,9 +9,11 @@ export function configCommand() {
     }
     // Display config with masked sensitive values
     const displayConfig = {
-        ...allConfig,
         apiKey: allConfig.apiKey ? maskApiKey(allConfig.apiKey) : undefined,
-        supabaseAnonKey: allConfig.supabaseAnonKey ? maskSensitive(allConfig.supabaseAnonKey) : undefined
+        organizationId: allConfig.organizationId,
+        organizationName: allConfig.organizationName,
+        defaultProject: allConfig.defaultProject,
+        defaultLanguage: allConfig.defaultLanguage
     };
     Object.entries(displayConfig).forEach(([key, value]) => {
         if (value !== undefined) {
@@ -25,9 +27,4 @@ function maskApiKey(key) {
         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.js

@@ -1,16 +1,13 @@
 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');
+    // Initialize supabase (with hardcoded credentials)
     try {
-        initializeSupabase(url, key);
+        initializeSupabase();
     }
     catch (e) {
-        console.error(chalk.red('✗ Supabase not initialized. Run "langctl init" first.'));
+        console.error(chalk.red('✗ Failed to connect to Langctl servers.'));
         return;
     }
     const supabase = getSupabase();
@@ -21,14 +18,12 @@ export async function debugListApiKeys() {
         .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.'));
+        console.log(chalk.yellow('Hint: This is a debug command and may require elevated permissions.'));
         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)}...`));
+        console.log(chalk.yellow('No API keys visible with current permissions.'));
         return;
     }
     for (const row of data) {
@@ -36,13 +31,12 @@ export async function debugListApiKeys() {
     }
 }
 export async function debugListOrganizations() {
-    const url = config.get('supabaseUrl');
-    const key = config.get('supabaseAnonKey');
+    // Initialize supabase (with hardcoded credentials)
     try {
-        initializeSupabase(url, key);
+        initializeSupabase();
     }
     catch (e) {
-        console.error(chalk.red('✗ Supabase not initialized. Run "langctl init" first.'));
+        console.error(chalk.red('✗ Failed to connect to Langctl servers.'));
         return;
     }
     const supabase = getSupabase();

package/dist/commands/export.d.ts

@@ -0,0 +1,14 @@
+type ExportFormat = 'i18n-json' | 'android-xml' | 'ios-strings' | 'flutter-arb' | 'flat-json' | 'nested-json';
+interface ExportOptions {
+    language?: string;
+    format?: ExportFormat;
+    output?: string;
+    module?: string;
+    includeUnpublished?: boolean;
+}
+/**
+ * Export translations command
+ */
+export declare function exportCommand(projectSlug: string, options: ExportOptions): Promise<void>;
+export {};
+//# sourceMappingURL=export.d.ts.map

package/dist/commands/export.js

@@ -0,0 +1,115 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { isAuthenticated, getApiKey } from '../auth.js';
+const EDGE_FUNCTION_URL = 'https://bcgnmvkgkbhbxzzflwdb.supabase.co/functions/v1/export-translations';
+const LIST_PROJECTS_URL = 'https://bcgnmvkgkbhbxzzflwdb.supabase.co/functions/v1/list-projects';
+/**
+ * Get project by slug
+ */
+async function getProjectBySlug(apiKey, slug) {
+    try {
+        const response = await fetch(LIST_PROJECTS_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-Key': apiKey
+            }
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = await response.json();
+        if (!data.success || !data.projects) {
+            return null;
+        }
+        return data.projects.find((p) => p.slug === slug) || null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Export translations command
+ */
+export async function exportCommand(projectSlug, options) {
+    // Check authentication
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        return;
+    }
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        console.log(chalk.red('✗ API key not found. Please run "langctl auth <api-key>" again.\n'));
+        return;
+    }
+    const spinner = ora('Fetching project...').start();
+    try {
+        // Get project by slug
+        const project = await getProjectBySlug(apiKey, projectSlug);
+        if (!project) {
+            spinner.fail(chalk.red(`Project "${projectSlug}" not found`));
+            console.log(chalk.yellow('\nRun "langctl projects list" to see available projects.\n'));
+            return;
+        }
+        spinner.text = 'Exporting translations...';
+        // Determine languages to export
+        const languages = options.language
+            ? [options.language]
+            : project.languages;
+        // Validate language if specified
+        if (options.language && !project.languages.includes(options.language)) {
+            spinner.fail(chalk.red(`Language "${options.language}" not found in project`));
+            console.log(chalk.yellow(`Available languages: ${project.languages.join(', ')}\n`));
+            return;
+        }
+        const format = options.format || 'flat-json';
+        const publishedOnly = !options.includeUnpublished;
+        // Export each language
+        for (const language of languages) {
+            spinner.text = `Exporting ${language}...`;
+            const response = await fetch(EDGE_FUNCTION_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-API-Key': apiKey
+                },
+                body: JSON.stringify({
+                    projectId: project.id,
+                    language,
+                    format,
+                    publishedOnly,
+                    module: options.module
+                })
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(errorData.error || `HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (!data.success || !data.content) {
+                throw new Error(data.error || 'Failed to export translations');
+            }
+            // Determine output path
+            const outputPath = options.output
+                ? options.output
+                : join(process.cwd(), 'translations', data.filename || `${language}.json`);
+            // Ensure directory exists
+            mkdirSync(dirname(outputPath), { recursive: true });
+            // Write file
+            writeFileSync(outputPath, data.content, 'utf-8');
+            spinner.succeed(chalk.green(`Exported ${language} → ${outputPath}`));
+            // Show spinner again if there are more languages
+            if (languages.indexOf(language) < languages.length - 1) {
+                spinner.start();
+            }
+        }
+        console.log(chalk.blue(`\n✓ Exported ${languages.length} language(s) successfully\n`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to export translations'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+    }
+}
+//# sourceMappingURL=export.js.map

package/dist/commands/import.d.ts

@@ -0,0 +1,11 @@
+interface ImportOptions {
+    language: string;
+    overwrite?: boolean;
+    publish?: boolean;
+}
+/**
+ * Import translations command
+ */
+export declare function importCommand(projectSlug: string, filePath: string, options: ImportOptions): Promise<void>;
+export {};
+//# sourceMappingURL=import.d.ts.map

package/dist/commands/import.js

@@ -0,0 +1,171 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { isAuthenticated, getApiKey } from '../auth.js';
+const PUSH_TRANSLATIONS_URL = 'https://bcgnmvkgkbhbxzzflwdb.supabase.co/functions/v1/push-translations';
+const LIST_PROJECTS_URL = 'https://bcgnmvkgkbhbxzzflwdb.supabase.co/functions/v1/list-projects';
+/**
+ * Get project by slug
+ */
+async function getProjectBySlug(apiKey, slug) {
+    try {
+        const response = await fetch(LIST_PROJECTS_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-Key': apiKey
+            }
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = await response.json();
+        if (!data.success || !data.projects) {
+            return null;
+        }
+        return data.projects.find((p) => p.slug === slug) || null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Parse translation file based on extension
+ */
+function parseTranslationFile(filePath) {
+    const content = readFileSync(filePath, 'utf-8');
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    if (ext === 'json') {
+        const parsed = JSON.parse(content);
+        // Check if it's nested JSON and flatten it
+        if (isNestedObject(parsed)) {
+            return flattenObject(parsed);
+        }
+        return parsed;
+    }
+    throw new Error(`Unsupported file format: .${ext}. Only JSON files are currently supported.`);
+}
+/**
+ * Check if object has nested objects
+ */
+function isNestedObject(obj) {
+    return Object.values(obj).some(value => typeof value === 'object' && value !== null && !Array.isArray(value));
+}
+/**
+ * Flatten nested object to dot-notation keys
+ */
+function flattenObject(obj, prefix = '') {
+    const result = {};
+    Object.entries(obj).forEach(([key, value]) => {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'string') {
+            result[fullKey] = value;
+        }
+        else if (typeof value === 'object' && value !== null) {
+            Object.assign(result, flattenObject(value, fullKey));
+        }
+    });
+    return result;
+}
+/**
+ * Import translations command
+ */
+export async function importCommand(projectSlug, filePath, options) {
+    // Check authentication
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        return;
+    }
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        console.log(chalk.red('✗ API key not found. Please run "langctl auth <api-key>" again.\n'));
+        return;
+    }
+    const spinner = ora('Loading file...').start();
+    try {
+        // Resolve file path
+        const resolvedPath = resolve(filePath);
+        // Parse translation file
+        spinner.text = 'Parsing translation file...';
+        const translations = parseTranslationFile(resolvedPath);
+        const keyCount = Object.keys(translations).length;
+        if (keyCount === 0) {
+            spinner.warn(chalk.yellow('No translations found in file'));
+            return;
+        }
+        spinner.text = 'Fetching project...';
+        // Get project by slug
+        const project = await getProjectBySlug(apiKey, projectSlug);
+        if (!project) {
+            spinner.fail(chalk.red(`Project "${projectSlug}" not found`));
+            console.log(chalk.yellow('\nRun "langctl projects list" to see available projects.\n'));
+            return;
+        }
+        // Validate language
+        if (!project.languages.includes(options.language)) {
+            spinner.fail(chalk.red(`Language "${options.language}" not found in project`));
+            console.log(chalk.yellow(`Available languages: ${project.languages.join(', ')}\n`));
+            return;
+        }
+        spinner.text = `Importing ${keyCount} translations...`;
+        // Push translations
+        const response = await fetch(PUSH_TRANSLATIONS_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-Key': apiKey
+            },
+            body: JSON.stringify({
+                projectId: project.id,
+                language: options.language,
+                translations,
+                publish: options.publish || false,
+                createMissing: true
+            })
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(errorData.error || `HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (!data.success && data.errors.length > 0) {
+            spinner.fail(chalk.red('Import completed with errors'));
+            console.log(chalk.green(`\n✓ Created: ${data.created}`));
+            console.log(chalk.blue(`✓ Updated: ${data.updated}`));
+            console.log(chalk.yellow(`⊘ Skipped: ${data.skipped}`));
+            console.log(chalk.red(`✗ Errors: ${data.errors.length}\n`));
+            if (data.errors.length > 0) {
+                console.log(chalk.red('Errors:'));
+                data.errors.slice(0, 5).forEach(err => {
+                    console.log(chalk.red(`  - ${err.key}: ${err.error}`));
+                });
+                if (data.errors.length > 5) {
+                    console.log(chalk.gray(`  ... and ${data.errors.length - 5} more errors\n`));
+                }
+            }
+            return;
+        }
+        spinner.succeed(chalk.green('Import completed successfully'));
+        console.log(chalk.green(`\n✓ Created: ${data.created}`));
+        console.log(chalk.blue(`✓ Updated: ${data.updated}`));
+        console.log(chalk.yellow(`⊘ Skipped: ${data.skipped}`));
+        if (options.publish) {
+            console.log(chalk.green('✓ Keys published'));
+        }
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to import translations'));
+        if (error.code === 'ENOENT') {
+            console.error(chalk.red(`Error: File not found: ${filePath}\n`));
+        }
+        else if (error instanceof SyntaxError) {
+            console.error(chalk.red(`Error: Invalid JSON file\n`));
+        }
+        else {
+            console.error(chalk.red(`Error: ${error.message}\n`));
+        }
+    }
+}
+//# sourceMappingURL=import.js.map

package/dist/commands/init.js

@@ -5,9 +5,6 @@ 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();
@@ -28,12 +25,9 @@ export async function initCommand() {
             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
+    // Initialize Supabase client (with hardcoded credentials - user doesn't need to know)
     try {
-        initializeSupabase(SUPABASE_URL, SUPABASE_ANON_KEY);
+        initializeSupabase();
     }
     catch (error) {
         console.error(chalk.red('✗ Failed to connect to Langctl servers'));

package/dist/commands/keys.d.ts

@@ -0,0 +1,25 @@
+/**
+ * List translation keys
+ */
+export declare function listKeysCommand(projectSlug: string, options: any): Promise<void>;
+/**
+ * Get single key
+ */
+export declare function getKeyCommand(projectSlug: string, keyName: string): Promise<void>;
+/**
+ * Create translation key
+ */
+export declare function createKeyCommand(projectSlug: string, keyName: string, options: any): Promise<void>;
+/**
+ * Delete translation key
+ */
+export declare function deleteKeyCommand(projectSlug: string, keyName: string): Promise<void>;
+/**
+ * Update single translation
+ */
+export declare function translateKeyCommand(projectSlug: string, keyName: string, options: any): Promise<void>;
+/**
+ * Publish/unpublish keys
+ */
+export declare function publishKeysCommand(projectSlug: string, keys: string[], options: any): Promise<void>;
+//# sourceMappingURL=keys.d.ts.map