langctl 0.2.0 → 0.4.0

package/dist/commands/auth.js

@@ -1,25 +1,91 @@
 import chalk from 'chalk';
-import ora from 'ora';
-import { authenticate, logout } from '../auth.js';
-import { config } from '../config.js';
-export async function authCommand(apiKey) {
-    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`));
+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 {
+        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 };
+    }
+    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');
+    }
+    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));
-        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://app.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,31 +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 = {
-        apiBaseUrl: allConfig.apiBaseUrl || 'https://api.langctl.com/api/v1 (default)',
-        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,125 +1,14 @@
-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';
+import { pullCommand } from './pull.js';
 /**
- * Map CLI format names to exporter format names
+ * `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.
  */
-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;
-    }
+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,
+    });
 }
-//# sourceMappingURL=export.js.map

package/dist/commands/import.js

@@ -1,150 +1,39 @@
 import chalk from 'chalk';
-import ora from 'ora';
-import { readFileSync } from 'fs';
-import { resolve } from 'path';
-import { isAuthenticated } from '../auth.js';
-import { getApiClient } from '../api.js';
-import { config } from '../config.js';
+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';
 /**
- * Parse translation file based on extension
+ * `langctl import [project] <file> --language <code>` — upload one file.
+ * The project may be omitted when langctl.json names it.
  */
-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) {
-    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('Loading file...').start();
+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 {
-        // 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 api = getApiClient();
-        const project = await api.get(`/orgs/${orgId}/projects/by-slug/${projectSlug}`);
-        // 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 via REST API
-        const body = {
-            language: options.language,
-            translations,
-            // Keep import safe by default; only overwrite when explicitly requested.
-            overwriteExisting: options.overwrite === true
-        };
-        if (options.module)
-            body.module = options.module;
-        const data = await api.post(`/orgs/${orgId}/projects/${project.id}/import`, body);
-        let publishedCount = 0;
-        if (options.publish) {
-            spinner.text = 'Publishing imported keys...';
-            const keyNames = new Set(Object.keys(translations));
-            const keyIds = [];
-            let page = 1;
-            const pageSize = 100;
-            while (true) {
-                const keysPage = await api.get(`/orgs/${orgId}/projects/${project.id}/keys`, {
-                    page: String(page),
-                    pageSize: String(pageSize)
-                });
-                for (const key of (keysPage.data || [])) {
-                    if (keyNames.has(key.key)) {
-                        keyIds.push(key.id);
-                    }
-                }
-                const totalPages = keysPage.pagination?.totalPages || 1;
-                if (page >= totalPages)
-                    break;
-                page += 1;
-            }
-            if (keyIds.length > 0) {
-                await api.post(`/orgs/${orgId}/projects/${project.id}/keys/bulk-publish`, {
-                    keyIds,
-                    published: true
-                });
-                publishedCount = keyIds.length;
-            }
-        }
-        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.magenta(`✓ Published: ${publishedCount}`));
-        }
-        console.log(chalk.white(`  Total: ${data.total}`));
-        console.log('');
+        result = await uploadTranslations(session, project, language, translations, opts);
     }
-    catch (error) {
-        spinner.fail(chalk.red('Failed to import translations'));
-        if (error.code === 'ENOENT') {
-            console.error(chalk.red(`Error: File not found: ${filePath}\n`));
-            process.exitCode = 1;
-        }
-        else if (error instanceof SyntaxError) {
-            console.error(chalk.red(`Error: Invalid JSON file\n`));
-            process.exitCode = 1;
-        }
-        else {
-            console.error(chalk.red(`Error: ${error.message}\n`));
-            process.exitCode = 1;
-        }
+    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.'));
 }
-//# sourceMappingURL=import.js.map

package/dist/commands/init.js

@@ -1,77 +1,66 @@
-import inquirer from 'inquirer';
 import chalk from 'chalk';
-import ora from 'ora';
-import { config } from '../config.js';
-import { authenticate } from '../auth.js';
-import { showLogo } from '../utils/banner.js';
-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;
-        }
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { PROJECT_CONFIG_FILE, resolveCredentials, writeProjectConfig } from '../core/config.js';
+import { usageError } from '../core/errors.js';
+import { getSession } from '../core/http.js';
+import { isInteractive, log, printJson, runtime } from '../core/output.js';
+import { input, password } from '../core/prompts.js';
+import { FORMATS, getFormat } from '../formats/index.js';
+import { saveApiKey } from './auth.js';
+/**
+ * Set up a repository: authenticate if needed, then write langctl.json so that
+ * `langctl pull` / `langctl push` need no arguments (locally and in CI).
+ */
+export async function initCommand(opts) {
+    const interactive = isInteractive();
+    const target = join(process.cwd(), PROJECT_CONFIG_FILE);
+    if (existsSync(target) && !opts.force) {
+        throw usageError(`${PROJECT_CONFIG_FILE} already exists here.`, 'Edit it directly, or re-run with --force to replace it.');
     }
-    // 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}`));
+    if (!resolveCredentials()) {
+        if (!interactive)
+            throw usageError('Not authenticated.', 'Set LANGCTL_API_KEY, or run "langctl auth --stdin" first.');
+        log.info(`Create an API key at ${chalk.cyan('https://app.langctl.com/organization/api-keys')}`);
+        const org = await saveApiKey(await password('Paste your API key'));
+        log.success(`Authenticated to ${chalk.bold(org.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;
+    const session = await getSession();
+    const projects = await session.api.get(`/orgs/${session.orgId}/projects`);
+    if (projects.length === 0) {
+        throw usageError('This organization has no projects yet.', 'Create one with "langctl projects create <name>" or at https://app.langctl.com.');
+    }
+    let project = opts.project ? projects.find(p => p.slug === opts.project) : undefined;
+    if (opts.project && !project) {
+        throw usageError(`Project "${opts.project}" not found.`, `Available: ${projects.map(p => p.slug).join(', ')}`);
+    }
+    if (!project) {
+        if (projects.length === 1)
+            project = projects[0];
+        else if (!interactive)
+            throw usageError('Several projects exist — choose one with --project <slug>.', `Available: ${projects.map(p => p.slug).join(', ')}`);
+        else
+            project = await choose('Project', projects.map(p => ({ label: `${p.name} ${chalk.dim(`(${p.slug})`)}`, value: p })));
+    }
+    let format = opts.format ? getFormat(opts.format) : undefined;
+    if (!format) {
+        format = interactive ? await choose('Format', FORMATS.map(f => ({ label: f.label, value: f }))) : getFormat('json');
+    }
+    const output = opts.output ?? (interactive ? await input('Where should translation files go', format.defaultOutput) : format.defaultOutput);
+    const config = { project: project.slug, format: format.id, output };
+    writeProjectConfig(target, config);
+    if (runtime.json)
+        return printJson({ created: target, config });
+    log.success(`Wrote ${PROJECT_CONFIG_FILE} for ${chalk.bold(project.name)} (${project.languages.join(', ')})`);
+    log.info(`\nNext:\n  ${chalk.cyan('langctl pull')}          download translations into ${output}\n  ${chalk.cyan('langctl push')}          upload new ${project.defaultLanguage} strings\n  ${chalk.cyan('langctl pull --check')}  fail CI when committed files are out of date`);
+}
+async function choose(label, options) {
+    options.forEach((o, i) => log.info(`  ${chalk.cyan(String(i + 1).padStart(2))}  ${o.label}`));
+    for (;;) {
+        const answer = await input(`${label} [1-${options.length}]`, '1');
+        const n = Number(answer);
+        if (Number.isInteger(n) && n >= 1 && n <= options.length)
+            return options[n - 1].value;
+        log.warn(`Enter a number between 1 and ${options.length}.`);
     }
-    // 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