langctl 0.1.2 → 0.3.0

package/dist/commands/auth.js

@@ -1,33 +1,91 @@
 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)
+import { clearCredentials, configPath, maskApiKey, normalizeApiKey, readUserConfig, resolveApiUrl, resolveCredentials, writeUserConfig, } from '../core/config.js';
+import { CliError, ExitCode, usageError } from '../core/errors.js';
+import { ApiClient, validateKey } from '../core/http.js';
+import { isInteractive, log, printJson, runtime, spinner } from '../core/output.js';
+import { password, readStdin } from '../core/prompts.js';
+/** Validate a key against the API and store it in the user config. Returns the organization. */
+export async function saveApiKey(rawKey) {
+    const apiKey = normalizeApiKey(rawKey);
+    const apiUrl = resolveApiUrl();
+    const api = new ApiClient({ apiKey, apiUrl, source: 'flag' });
+    const spin = spinner('Verifying API key…');
     try {
-        initializeSupabase();
+        const info = await validateKey(api, apiKey);
+        if (!info) {
+            throw new CliError('This API key is invalid or has been revoked.', ExitCode.Auth, 'Create a new key at https://app.langctl.com/organization/api-keys.');
+        }
+        const org = await api.get(`/orgs/${info.organizationId}`);
+        writeUserConfig({ ...readUserConfig(), apiKey, organizationId: org.id, organizationName: org.name });
+        return { ...org, scopes: info.scopes };
     }
-    catch (error) {
-        console.log(chalk.red('✗ Failed to connect to Langctl servers.\n'));
-        return;
+    finally {
+        spin.stop();
+    }
+}
+export async function authCommand(apiKeyArg, opts) {
+    let key = apiKeyArg;
+    if (opts.stdin) {
+        key = (await readStdin()).trim();
+        if (!key)
+            throw usageError('No API key received on stdin.', 'Example: echo "$LANGCTL_API_KEY" | langctl auth --stdin');
     }
-    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 if (key) {
+        log.warn('Passing the key as an argument stores it in your shell history. Prefer "langctl auth --stdin" or the interactive prompt.');
+    }
+    else if (isInteractive()) {
+        key = await password('Paste your API key');
     }
     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'));
+        throw usageError('No API key given.', 'Use "langctl auth --stdin" (e.g. echo "$KEY" | langctl auth --stdin), or set LANGCTL_API_KEY instead of storing a key in CI.');
+    }
+    const org = await saveApiKey(key);
+    if (runtime.json) {
+        printJson({ authenticated: true, organization: { id: org.id, name: org.name, plan: org.plan }, scopes: org.scopes, configPath: configPath() });
+        return;
+    }
+    log.success(`Authenticated to ${chalk.bold(org.name)} (${org.plan} plan)`);
+    log.info(chalk.dim(`Key saved to ${configPath()} (readable only by you). Scopes: ${org.scopes.join(', ')}`));
+}
+export function logoutCommand() {
+    const removed = clearCredentials();
+    if (runtime.json)
+        return printJson({ loggedOut: removed });
+    log.success(removed ? 'Logged out — stored API key removed.' : 'No stored API key — nothing to do.');
+    if (process.env.LANGCTL_API_KEY)
+        log.warn('LANGCTL_API_KEY is still set in your environment and will keep being used.');
+}
+export async function whoamiCommand() {
+    const creds = resolveCredentials();
+    if (!creds) {
+        if (runtime.json)
+            printJson({ authenticated: false, apiUrl: resolveApiUrl() });
+        throw new CliError('Not authenticated.', ExitCode.Auth, 'Run "langctl auth --stdin", or set LANGCTL_API_KEY.');
+    }
+    const api = new ApiClient(creds);
+    const started = Date.now();
+    const info = await validateKey(api, creds.apiKey);
+    const latency = Date.now() - started;
+    if (!info) {
+        throw new CliError(`The API key from ${sourceLabel(creds.source)} is invalid or revoked.`, ExitCode.Auth, 'Create a new key at https://app.langctl.com/organization/api-keys.');
     }
+    const org = await api.get(`/orgs/${info.organizationId}`);
+    const data = {
+        authenticated: true,
+        organization: { id: org.id, name: org.name, slug: org.slug, plan: org.plan },
+        key: maskApiKey(creds.apiKey),
+        keySource: sourceLabel(creds.source),
+        scopes: info.scopes,
+        apiUrl: creds.apiUrl,
+        latencyMs: latency,
+    };
+    if (runtime.json)
+        return printJson(data);
+    log.out(`${chalk.bold(org.name)} ${chalk.dim(`(${org.slug}, ${org.plan} plan)`)}`);
+    log.out(`  key      ${data.key}  ${chalk.dim(`from ${data.keySource}`)}`);
+    log.out(`  scopes   ${info.scopes.join(', ')}`);
+    log.out(`  api      ${creds.apiUrl}  ${chalk.dim(`${latency}ms`)}`);
 }
-export async function logoutCommand() {
-    logout();
-    console.log(chalk.green('✓ Logged out successfully\n'));
+function sourceLabel(source) {
+    return source === 'env' ? 'LANGCTL_API_KEY' : source === 'flag' ? '--api-key' : configPath();
 }
-//# sourceMappingURL=auth.js.map

package/dist/commands/config.js

@@ -1,30 +1,41 @@
 import chalk from 'chalk';
-import { config } from '../config.js';
+import { configPath, loadProjectConfig, maskApiKey, readUserConfig, resolveApiUrl, resolveCredentials } from '../core/config.js';
+import { log, printJson, runtime } from '../core/output.js';
+import { FORMATS } from '../formats/index.js';
+/** Show effective configuration and where each value comes from (no network). */
 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 = {
-        apiKey: allConfig.apiKey ? maskApiKey(allConfig.apiKey) : undefined,
-        organizationId: allConfig.organizationId,
-        organizationName: allConfig.organizationName,
-        defaultProject: allConfig.defaultProject,
-        defaultLanguage: allConfig.defaultLanguage
+    const user = readUserConfig();
+    const creds = resolveCredentials();
+    const project = loadProjectConfig();
+    const data = {
+        apiUrl: resolveApiUrl(),
+        apiKey: creds ? maskApiKey(creds.apiKey) : null,
+        apiKeySource: creds ? (creds.source === 'env' ? 'LANGCTL_API_KEY' : creds.source === 'flag' ? '--api-key' : configPath()) : null,
+        organization: user.organizationName ?? null,
+        userConfig: configPath(),
+        projectConfig: project ? { path: project.path, ...project.config } : null,
     };
-    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`));
+    if (runtime.json)
+        return printJson(data);
+    log.out(`api url       ${data.apiUrl}`);
+    log.out(`api key       ${data.apiKey ?? chalk.yellow('not set')}${data.apiKeySource ? chalk.dim(`  (${data.apiKeySource})`) : ''}`);
+    if (data.organization)
+        log.out(`organization  ${data.organization}`);
+    log.out(`user config   ${data.userConfig}`);
+    if (project) {
+        log.out(`project file  ${project.path}`);
+        for (const [k, v] of Object.entries(project.config))
+            log.out(chalk.dim(`  ${k}: ${JSON.stringify(v)}`));
+    }
+    else {
+        log.out(`project file  ${chalk.dim('none — run "langctl init" to create langctl.json')}`);
+    }
 }
-function maskApiKey(key) {
-    if (key.length < 10)
-        return '***';
-    return `${key.substring(0, 10)}...${key.substring(key.length - 4)}`;
+export function formatsCommand() {
+    if (runtime.json)
+        return printJson(FORMATS.map(f => ({ id: f.id, aliases: f.aliases, description: f.label, defaultOutput: f.defaultOutput })));
+    for (const f of FORMATS) {
+        log.out(`${chalk.bold(f.id.padEnd(12))} ${f.label}`);
+        log.out(chalk.dim(`${''.padEnd(12)} default path ${f.defaultOutput}${f.aliases.length ? ` · aliases ${f.aliases.join(', ')}` : ''}`));
+    }
 }
-//# sourceMappingURL=config.js.map

package/dist/commands/export.js

@@ -1,115 +1,14 @@
-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';
+import { pullCommand } from './pull.js';
 /**
- * Get project by slug
+ * `langctl export` — 0.2.x-compatible entry point. Same engine as `pull`, but
+ * aimed at one-off exports (`-l es -o es.json`); `pull` is the CI/repo workflow.
  */
-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 async function exportCommand(projectArg, opts) {
+    await pullCommand(projectArg, {
+        languages: opts.languages ?? opts.language,
+        format: opts.format,
+        output: opts.output,
+        module: opts.module,
+        includeDrafts: opts.includeDrafts || opts.includeUnpublished,
+    });
 }
-/**
- * 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.js

@@ -1,171 +1,39 @@
 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';
+import { relative, resolve } from 'path';
+import { loadProjectConfig } from '../core/config.js';
+import { usageError } from '../core/errors.js';
+import { getSession } from '../core/http.js';
+import { log, printJson, runtime, spinner } from '../core/output.js';
+import { assertLanguages, getProject, projectSlugFrom } from '../core/project.js';
+import { getFormat } from '../formats/index.js';
+import { readTranslationFile, uploadTranslations } from './push.js';
 /**
- * Get project by slug
+ * `langctl import [project] <file> --language <code>` — upload one file.
+ * The project may be omitted when langctl.json names it.
  */
-async function getProjectBySlug(apiKey, slug) {
+export async function importCommand(first, second, opts) {
+    const [projectArg, file] = second === undefined ? [undefined, first] : [first, second];
+    const session = await getSession();
+    const project = await getProject(session, projectSlugFrom(projectArg));
+    const language = opts.language ?? loadProjectConfig()?.config.sourceLanguage ?? project.defaultLanguage;
+    if (!opts.language)
+        log.info(chalk.dim(`No --language given; importing as ${language} (the project's default).`));
+    assertLanguages(project, [language]);
+    const path = resolve(file);
+    const translations = readTranslationFile(path, opts.format ? getFormat(opts.format) : undefined, language);
+    if (Object.keys(translations).length === 0)
+        throw usageError(`${relative(process.cwd(), path)} contains no translations.`);
+    const spin = spinner(`${opts.dryRun ? 'Checking' : 'Importing'} ${Object.keys(translations).length} keys…`);
+    let result;
     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;
+        result = await uploadTranslations(session, project, language, translations, opts);
     }
-    catch (error) {
-        return null;
+    finally {
+        spin.stop();
     }
+    if (runtime.json)
+        return printJson({ project: project.slug, file: relative(process.cwd(), path), dryRun: Boolean(opts.dryRun), ...result });
+    log.out(`${language}  ${chalk.green(`${result.created} new`)}, ${chalk.yellow(`${result.updated} updated`)}, ${chalk.dim(`${result.unchanged} unchanged`)}${result.published !== undefined ? `, ${chalk.cyan(`${result.published} published`)}` : ''}${opts.dryRun ? chalk.dim('  (dry run)') : ''}`);
+    if (!opts.overwrite && result.unchanged > 0)
+        log.info(chalk.dim('Existing translations are kept unless you pass --overwrite.'));
 }
-/**
- * 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