langctl 0.1.1 → 0.2.0

package/dist/api.d.ts

@@ -0,0 +1,20 @@
+export declare class ApiClient {
+    private baseUrl;
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    private request;
+    get<T>(path: string, params?: Record<string, string>): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}
+/**
+ * Create an API client from the current config.
+ * Throws if not authenticated.
+ */
+export declare function getApiClient(): ApiClient;
+/**
+ * Create an API client with a specific API key (for auth flow before key is saved).
+ */
+export declare function createApiClient(apiKey: string): ApiClient;
+//# sourceMappingURL=api.d.ts.map

package/dist/api.js

@@ -0,0 +1,75 @@
+import { config } from './config.js';
+const DEFAULT_API_URL = 'https://api.langctl.com/api/v1';
+export class ApiClient {
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.apiKey = apiKey;
+    }
+    async request(method, path, body, params) {
+        let url = `${this.baseUrl}${path}`;
+        if (params && Object.keys(params).length > 0) {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null && value !== '') {
+                    searchParams.append(key, value);
+                }
+            }
+            const qs = searchParams.toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        const headers = {
+            'X-API-Key': this.apiKey,
+        };
+        if (body !== undefined) {
+            headers['Content-Type'] = 'application/json';
+        }
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(errorData.error || errorData.message || `HTTP ${response.status}: ${response.statusText}`);
+        }
+        // Handle 204 No Content
+        if (response.status === 204) {
+            return undefined;
+        }
+        return response.json();
+    }
+    async get(path, params) {
+        return this.request('GET', path, undefined, params);
+    }
+    async post(path, body) {
+        return this.request('POST', path, body);
+    }
+    async patch(path, body) {
+        return this.request('PATCH', path, body);
+    }
+    async delete(path) {
+        return this.request('DELETE', path);
+    }
+}
+/**
+ * Create an API client from the current config.
+ * Throws if not authenticated.
+ */
+export function getApiClient() {
+    const apiKey = config.get('apiKey');
+    const baseUrl = config.get('apiBaseUrl') || DEFAULT_API_URL;
+    if (!apiKey) {
+        throw new Error('Not authenticated. Please run "langctl auth <api-key>" first.');
+    }
+    return new ApiClient(baseUrl, apiKey);
+}
+/**
+ * Create an API client with a specific API key (for auth flow before key is saved).
+ */
+export function createApiClient(apiKey) {
+    const baseUrl = config.get('apiBaseUrl') || DEFAULT_API_URL;
+    return new ApiClient(baseUrl, apiKey);
+}
+//# sourceMappingURL=api.js.map

package/dist/auth.d.ts

@@ -1,13 +1,14 @@
 export interface ApiKeyData {
-    organization_id: string;
+    organizationId: string;
     organization: {
         id: string;
         name: string;
+        slug: string;
         plan: string;
     };
 }
 /**
- * Verify API key via Edge Function
+ * Verify API key via Fastify API
  */
 export declare function verifyApiKey(plainTextKey: string): Promise<ApiKeyData | null>;
 /**
@@ -26,6 +27,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

@@ -1,6 +1,5 @@
 import { config } from './config.js';
-// Edge Function URL
-const EDGE_FUNCTION_URL = 'https://bcgnmvkgkbhbxzzflwdb.supabase.co/functions/v1/verify-api-key';
+import { createApiClient } from './api.js';
 // Normalize and validate API key input
 function sanitizeApiKey(input) {
     const raw = (input || '').trim().toLowerCase();
@@ -15,7 +14,7 @@ function sanitizeApiKey(input) {
     return { ok: true, key: `lc_${hexOnly}` };
 }
 /**
- * Verify API key via Edge Function
+ * Verify API key via Fastify API
  */
 export async function verifyApiKey(plainTextKey) {
     try {
@@ -23,33 +22,28 @@ export async function verifyApiKey(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 })
+        // Create a temporary API client with the key to validate
+        const client = createApiClient(sanitized.key);
+        // Validate the API key
+        const validateResult = await client.post('/api-keys/validate', {
+            apiKey: sanitized.key,
         });
-        if (!response.ok) {
-            return null;
-        }
-        const data = await response.json();
-        if (!data.success) {
+        if (!validateResult.valid) {
             return null;
         }
-        // Map Edge Function response to ApiKeyData format
+        // Fetch organization details
+        const org = await client.get(`/orgs/${validateResult.organizationId}`);
         return {
-            organization_id: data.organizationId,
+            organizationId: validateResult.organizationId,
             organization: {
-                id: data.organizationId,
-                name: data.organizationName,
-                plan: data.plan
-            }
+                id: org.id,
+                name: org.name,
+                slug: org.slug,
+                plan: org.plan,
+            },
         };
     }
     catch (error) {
-        console.error('Error verifying API key:', error);
         return null;
     }
 }
@@ -61,25 +55,25 @@ export async function authenticate(apiKey) {
     if (!sanitized.ok || !sanitized.key) {
         return {
             success: false,
-            message: sanitized.message || 'Invalid API key format. Expected format: lc_[64 hex characters]'
+            message: sanitized.message || 'Invalid API key format. Expected format: lc_[64 hex characters]',
         };
     }
-    // Verify via Edge Function
+    // Verify via Fastify API
     const keyData = await verifyApiKey(sanitized.key);
     if (!keyData) {
         return {
             success: false,
-            message: 'Invalid or revoked API key. Please check your key and try again.'
+            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('organizationId', keyData.organizationId);
     config.set('organizationName', keyData.organization.name);
     return {
         success: true,
         message: `Successfully authenticated as ${keyData.organization.name}`,
-        data: keyData
+        data: keyData,
     };
 }
 /**
@@ -94,6 +88,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

@@ -2,16 +2,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { authenticate, logout } from '../auth.js';
 import { config } from '../config.js';
-import { initializeSupabase } from '../supabase.js';
 export async function authCommand(apiKey) {
-    // Initialize Supabase (with hardcoded credentials)
-    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) {
@@ -20,10 +11,11 @@ export async function authCommand(apiKey) {
     }
     else {
         spinner.fail(chalk.red(result.message));
+        process.exitCode = 1;
         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'));
+        console.log(chalk.white('  - Generate a new key: https://app.langctl.com/dashboard/settings/api-keys\n'));
     }
 }
 export async function logoutCommand() {

package/dist/commands/config.js

@@ -9,6 +9,7 @@ export function configCommand() {
     }
     // Display config with masked sensitive values
     const displayConfig = {
+        apiBaseUrl: allConfig.apiBaseUrl || 'https://api.langctl.com/api/v1 (default)',
         apiKey: allConfig.apiKey ? maskApiKey(allConfig.apiKey) : undefined,
         organizationId: allConfig.organizationId,
         organizationName: allConfig.organizationName,

package/dist/commands/debug.js

@@ -1,57 +1,61 @@
 import chalk from 'chalk';
 import ora from 'ora';
-import { getSupabase, initializeSupabase } from '../supabase.js';
+import { isAuthenticated } from '../auth.js';
+import { getApiClient } from '../api.js';
+import { config } from '../config.js';
 export async function debugListApiKeys() {
-    // Initialize supabase (with hardcoded credentials)
-    try {
-        initializeSupabase();
-    }
-    catch (e) {
-        console.error(chalk.red('✗ Failed to connect to Langctl servers.'));
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated.\n'));
+        process.exitCode = 1;
         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: This is a debug command and may require elevated permissions.'));
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ No organization configured.\n'));
+        process.exitCode = 1;
         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 permissions.'));
-        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')}`);
+    const spinner = ora('Testing API connection...').start();
+    try {
+        const api = getApiClient();
+        const org = await api.get(`/orgs/${orgId}`);
+        spinner.succeed(chalk.green(`API connection successful`));
+        console.log(chalk.blue.bold('\n🔧 Debug Info\n'));
+        console.log(chalk.white(`Organization: ${org.name}`));
+        console.log(chalk.white(`Plan: ${org.plan}`));
+        console.log(chalk.gray(`API URL: ${config.get('apiBaseUrl') || 'https://api.langctl.com/api/v1'}`));
+        console.log(chalk.gray(`Config: ${config.getConfigPath()}`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail(chalk.red('API connection failed'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
     }
 }
 export async function debugListOrganizations() {
-    // Initialize supabase (with hardcoded credentials)
-    try {
-        initializeSupabase();
-    }
-    catch (e) {
-        console.error(chalk.red('✗ Failed to connect to Langctl servers.'));
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated.\n'));
+        process.exitCode = 1;
         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}`));
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ No organization configured.\n'));
+        process.exitCode = 1;
         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)}`);
-    });
+    const spinner = ora('Fetching organization...').start();
+    try {
+        const api = getApiClient();
+        const org = await api.get(`/orgs/${orgId}`);
+        spinner.succeed(chalk.green('Found organization'));
+        console.log(`${chalk.cyan(org.id)}  ${chalk.white(org.name)}  plan=${chalk.magenta(org.plan)}  created=${chalk.gray(org.createdAt)}`);
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to fetch organization'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exitCode = 1;
+    }
 }
 //# sourceMappingURL=debug.js.map

package/dist/commands/export.d.ts

@@ -0,0 +1,13 @@
+interface ExportOptions {
+    language?: string;
+    format?: string;
+    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,125 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { isAuthenticated } from '../auth.js';
+import { getApiClient } from '../api.js';
+import { config } from '../config.js';
+import { exportTranslations } from '../exporters/index.js';
+/**
+ * Map CLI format names to exporter format names
+ */
+const formatMap = {
+    'flat-json': 'json',
+    'nested-json': 'json-nested',
+    'i18n-json': 'json',
+    'android-xml': 'android',
+    'ios-strings': 'ios',
+    'flutter-arb': 'flutter',
+    // Also accept exporter format names directly
+    'json': 'json',
+    'json-nested': 'json-nested',
+    'android': 'android',
+    'ios': 'ios',
+    'flutter': 'flutter',
+};
+/**
+ * Get file extension for a given export format
+ */
+function getFileExtension(format, language) {
+    switch (format) {
+        case 'json':
+        case 'json-nested':
+            return `${language}.json`;
+        case 'android':
+            return `strings.xml`;
+        case 'ios':
+            return `Localizable.strings`;
+        case 'flutter':
+            return `intl_${language}.arb`;
+        default:
+            return `${language}.json`;
+    }
+}
+/**
+ * Export translations command
+ */
+export async function exportCommand(projectSlug, options) {
+    if (!isAuthenticated()) {
+        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const orgId = config.get('organizationId');
+    if (!orgId) {
+        console.log(chalk.red('✗ Organization ID not found. Please run "langctl auth <api-key>" again.\n'));
+        process.exitCode = 1;
+        return;
+    }
+    const spinner = ora('Fetching project...').start();
+    try {
+        const api = getApiClient();
+        // Resolve project by slug
+        const project = await api.get(`/orgs/${orgId}/projects/by-slug/${projectSlug}`);
+        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;
+        }
+        // Resolve format
+        const cliFormat = options.format || 'flat-json';
+        const exportFormat = formatMap[cliFormat];
+        if (!exportFormat) {
+            spinner.fail(chalk.red(`Unsupported format: ${cliFormat}`));
+            console.log(chalk.yellow(`Valid formats: ${Object.keys(formatMap).join(', ')}\n`));
+            return;
+        }
+        const publishedOnly = !options.includeUnpublished;
+        // Export each language
+        for (const language of languages) {
+            spinner.text = `Exporting ${language}...`;
+            // Fetch flat translations from the API
+            const params = {
+                language,
+                publishedOnly: publishedOnly ? 'true' : 'false'
+            };
+            if (options.module)
+                params.module = options.module;
+            const result = await api.get(`/orgs/${orgId}/projects/${project.id}/export`, params);
+            // Convert flat translations to TranslationKey array for the exporter
+            const flatTranslations = result.translations || {};
+            const translationKeys = Object.entries(flatTranslations).map(([key, value]) => ({
+                key,
+                translations: { [language]: value }
+            }));
+            // Use client-side exporter for format conversion
+            const exportResult = exportTranslations(translationKeys, language, exportFormat);
+            // Determine output path
+            const outputPath = options.output
+                ? options.output
+                : join(process.cwd(), 'translations', getFileExtension(exportFormat, language));
+            // Ensure directory exists
+            mkdirSync(dirname(outputPath), { recursive: true });
+            // Write file
+            writeFileSync(outputPath, exportResult.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`));
+        process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=export.js.map

package/dist/commands/import.d.ts

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