newo 1.4.0 → 1.5.1

package/dist/auth.js

@@ -0,0 +1,361 @@
+import fs from 'fs-extra';
+import path from 'path';
+import axios, { AxiosError } from 'axios';
+import { ENV } from './env.js';
+import { customerStateDir } from './fsutil.js';
+const STATE_DIR = path.join(process.cwd(), '.newo');
+// Constants for validation and timeouts
+const API_KEY_MIN_LENGTH = 10;
+const TOKEN_MIN_LENGTH = 20;
+const REQUEST_TIMEOUT = 30000; // 30 seconds
+const TOKEN_EXPIRY_BUFFER = 60000; // 1 minute buffer for token expiry
+// Validation functions
+function validateApiKey(apiKey, customerIdn) {
+    if (!apiKey || typeof apiKey !== 'string') {
+        throw new Error(`Invalid API key format${customerIdn ? ` for customer ${customerIdn}` : ''}: must be a non-empty string`);
+    }
+    if (apiKey.length < API_KEY_MIN_LENGTH) {
+        throw new Error(`API key too short${customerIdn ? ` for customer ${customerIdn}` : ''}: minimum ${API_KEY_MIN_LENGTH} characters required`);
+    }
+    if (apiKey.includes(' ') || apiKey.includes('\n') || apiKey.includes('\t')) {
+        throw new Error(`Invalid API key format${customerIdn ? ` for customer ${customerIdn}` : ''}: contains invalid characters`);
+    }
+}
+function validateTokens(tokens) {
+    if (!tokens.access_token || typeof tokens.access_token !== 'string' || tokens.access_token.length < TOKEN_MIN_LENGTH) {
+        throw new Error('Invalid access token format: must be a non-empty string with minimum length');
+    }
+    if (tokens.refresh_token && (typeof tokens.refresh_token !== 'string' || tokens.refresh_token.length < TOKEN_MIN_LENGTH)) {
+        throw new Error('Invalid refresh token format: must be a non-empty string with minimum length');
+    }
+    if (tokens.expires_at && (typeof tokens.expires_at !== 'number' || tokens.expires_at <= 0)) {
+        throw new Error('Invalid token expiry: must be a positive number');
+    }
+}
+function validateUrl(url, name) {
+    if (!url || typeof url !== 'string') {
+        throw new Error(`${name} must be a non-empty string`);
+    }
+    try {
+        new URL(url);
+    }
+    catch {
+        throw new Error(`${name} must be a valid URL format`);
+    }
+    if (!url.startsWith('https://') && !url.startsWith('http://')) {
+        throw new Error(`${name} must use HTTP or HTTPS protocol`);
+    }
+}
+// Enhanced logging function
+function logAuthEvent(level, message, meta) {
+    const timestamp = new Date().toISOString();
+    const logEntry = {
+        timestamp,
+        level,
+        module: 'auth',
+        message,
+        ...meta
+    };
+    // Sanitize sensitive data
+    const sanitized = JSON.parse(JSON.stringify(logEntry, (key, value) => {
+        if (typeof key === 'string' && (key.toLowerCase().includes('key') || key.toLowerCase().includes('token') || key.toLowerCase().includes('secret'))) {
+            return typeof value === 'string' ? `${value.slice(0, 8)}...` : value;
+        }
+        return value;
+    }));
+    if (level === 'error') {
+        console.error(JSON.stringify(sanitized));
+    }
+    else if (level === 'warn') {
+        console.warn(JSON.stringify(sanitized));
+    }
+    else {
+        console.log(JSON.stringify(sanitized));
+    }
+}
+// Enhanced error handling for network requests
+function handleNetworkError(error, operation, customerIdn) {
+    const customerInfo = customerIdn ? ` for customer ${customerIdn}` : '';
+    if (error instanceof AxiosError) {
+        const statusCode = error.response?.status;
+        const responseData = error.response?.data;
+        if (statusCode === 401) {
+            throw new Error(`Authentication failed${customerInfo}: Invalid API key or credentials`);
+        }
+        else if (statusCode === 403) {
+            throw new Error(`Access forbidden${customerInfo}: Insufficient permissions`);
+        }
+        else if (statusCode === 429) {
+            throw new Error(`Rate limit exceeded${customerInfo}: Please try again later`);
+        }
+        else if (statusCode && statusCode >= 500) {
+            throw new Error(`Server error${customerInfo}: The NEWO service is temporarily unavailable (${statusCode})`);
+        }
+        else if (error.code === 'ECONNREFUSED') {
+            throw new Error(`Connection refused${customerInfo}: Cannot reach NEWO service`);
+        }
+        else if (error.code === 'ETIMEDOUT' || error.code === 'ENOTFOUND') {
+            throw new Error(`Network timeout${customerInfo}: Check your internet connection`);
+        }
+        else {
+            throw new Error(`Network error during ${operation}${customerInfo}: ${error.message}${responseData ? ` - ${JSON.stringify(responseData)}` : ''}`);
+        }
+    }
+    throw new Error(`Failed to ${operation}${customerInfo}: ${error instanceof Error ? error.message : String(error)}`);
+}
+function tokensPath(customerIdn) {
+    if (customerIdn) {
+        return path.join(customerStateDir(customerIdn), 'tokens.json');
+    }
+    return path.join(STATE_DIR, 'tokens.json'); // Legacy path
+}
+async function saveTokens(tokens, customerIdn) {
+    try {
+        validateTokens(tokens);
+        const filePath = tokensPath(customerIdn);
+        await fs.ensureDir(path.dirname(filePath));
+        await fs.writeJson(filePath, tokens, { spaces: 2 });
+        logAuthEvent('info', 'Tokens saved successfully', {
+            customerIdn: customerIdn || 'legacy',
+            expiresAt: tokens.expires_at ? new Date(tokens.expires_at).toISOString() : undefined,
+            hasRefreshToken: !!tokens.refresh_token
+        });
+    }
+    catch (error) {
+        logAuthEvent('error', 'Failed to save tokens', {
+            customerIdn: customerIdn || 'legacy',
+            error: error instanceof Error ? error.message : String(error)
+        });
+        throw new Error(`Failed to save authentication tokens${customerIdn ? ` for customer ${customerIdn}` : ''}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function loadTokens(customerIdn) {
+    try {
+        const filePath = tokensPath(customerIdn);
+        if (await fs.pathExists(filePath)) {
+            const tokens = await fs.readJson(filePath);
+            // Validate loaded tokens
+            try {
+                validateTokens(tokens);
+            }
+            catch (validationError) {
+                logAuthEvent('warn', 'Loaded tokens failed validation, will regenerate', {
+                    customerIdn: customerIdn || 'legacy',
+                    error: validationError instanceof Error ? validationError.message : String(validationError)
+                });
+                return null; // Force token regeneration
+            }
+            logAuthEvent('info', 'Tokens loaded successfully', {
+                customerIdn: customerIdn || 'legacy',
+                expiresAt: tokens.expires_at ? new Date(tokens.expires_at).toISOString() : undefined,
+                hasRefreshToken: !!tokens.refresh_token
+            });
+            return tokens;
+        }
+    }
+    catch (error) {
+        logAuthEvent('warn', 'Failed to load tokens from file', {
+            customerIdn: customerIdn || 'legacy',
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    // Fallback to environment tokens for legacy mode or bootstrap
+    if (!customerIdn && (ENV.NEWO_ACCESS_TOKEN || ENV.NEWO_REFRESH_TOKEN)) {
+        const tokens = {
+            access_token: ENV.NEWO_ACCESS_TOKEN || '',
+            refresh_token: ENV.NEWO_REFRESH_TOKEN || '',
+            expires_at: Date.now() + 10 * 60 * 1000
+        };
+        await saveTokens(tokens);
+        return tokens;
+    }
+    return null;
+}
+function isExpired(tokens) {
+    if (!tokens?.expires_at) {
+        logAuthEvent('warn', 'Token has no expiry time, treating as expired');
+        return true;
+    }
+    const currentTime = Date.now();
+    const expiryTime = tokens.expires_at;
+    const timeUntilExpiry = expiryTime - currentTime;
+    if (timeUntilExpiry <= TOKEN_EXPIRY_BUFFER) {
+        logAuthEvent('info', 'Token is expired or expires soon', {
+            expiresAt: new Date(expiryTime).toISOString(),
+            timeUntilExpiry: Math.round(timeUntilExpiry / 1000)
+        });
+        return true;
+    }
+    return false;
+}
+function normalizeTokenResponse(tokenResponse) {
+    const access = tokenResponse.access_token || tokenResponse.token || tokenResponse.accessToken;
+    const refresh = tokenResponse.refresh_token || tokenResponse.refreshToken || '';
+    const expiresInSec = tokenResponse.expires_in || tokenResponse.expiresIn || 3600;
+    if (!access) {
+        throw new Error('Invalid token response: missing access token');
+    }
+    return { access, refresh, expiresInSec };
+}
+export async function exchangeApiKeyForToken(customer) {
+    const apiKey = customer?.apiKey || ENV.NEWO_API_KEY;
+    const customerIdn = customer?.idn;
+    // Validate inputs
+    if (!apiKey) {
+        throw new Error(customer
+            ? `API key not set for customer ${customer.idn}. Set NEWO_CUSTOMER_${customer.idn.toUpperCase()}_API_KEY in your environment`
+            : 'NEWO_API_KEY not set. Provide an API key in .env file');
+    }
+    validateApiKey(apiKey, customerIdn);
+    validateUrl(ENV.NEWO_BASE_URL, 'NEWO_BASE_URL');
+    logAuthEvent('info', 'Exchanging API key for tokens', { customerIdn: customerIdn || 'legacy' });
+    try {
+        const url = `${ENV.NEWO_BASE_URL}/api/v1/auth/api-key/token`;
+        const response = await axios.post(url, {}, {
+            timeout: REQUEST_TIMEOUT,
+            headers: {
+                'x-api-key': apiKey,
+                'accept': 'application/json',
+                'user-agent': 'newo-cli/1.5.0'
+            }
+        });
+        if (!response.data) {
+            throw new Error('Empty response from token exchange endpoint');
+        }
+        const { access, refresh, expiresInSec } = normalizeTokenResponse(response.data);
+        const tokens = {
+            access_token: access,
+            refresh_token: refresh,
+            expires_at: Date.now() + expiresInSec * 1000
+        };
+        // Validate tokens before saving
+        validateTokens(tokens);
+        await saveTokens(tokens, customerIdn);
+        logAuthEvent('info', 'API key exchange completed successfully', {
+            customerIdn: customerIdn || 'legacy',
+            expiresAt: new Date(tokens.expires_at).toISOString()
+        });
+        return tokens;
+    }
+    catch (error) {
+        logAuthEvent('error', 'API key exchange failed', {
+            customerIdn: customerIdn || 'legacy',
+            error: error instanceof Error ? error.message : String(error)
+        });
+        handleNetworkError(error, 'exchange API key for token', customerIdn);
+    }
+}
+export async function refreshWithEndpoint(refreshToken, customer) {
+    const customerIdn = customer?.idn;
+    // Validate inputs
+    if (!ENV.NEWO_REFRESH_URL) {
+        throw new Error('NEWO_REFRESH_URL not set in environment');
+    }
+    if (!refreshToken || typeof refreshToken !== 'string' || refreshToken.length < TOKEN_MIN_LENGTH) {
+        throw new Error(`Invalid refresh token${customerIdn ? ` for customer ${customerIdn}` : ''}: must be a non-empty string with minimum length`);
+    }
+    validateUrl(ENV.NEWO_REFRESH_URL, 'NEWO_REFRESH_URL');
+    logAuthEvent('info', 'Refreshing tokens using refresh endpoint', { customerIdn: customerIdn || 'legacy' });
+    try {
+        const response = await axios.post(ENV.NEWO_REFRESH_URL, { refresh_token: refreshToken }, {
+            timeout: REQUEST_TIMEOUT,
+            headers: {
+                'accept': 'application/json',
+                'user-agent': 'newo-cli/1.5.0'
+            }
+        });
+        if (!response.data) {
+            throw new Error('Empty response from token refresh endpoint');
+        }
+        const { access, expiresInSec } = normalizeTokenResponse(response.data);
+        const refresh = response.data.refresh_token || response.data.refreshToken || refreshToken;
+        const tokens = {
+            access_token: access,
+            refresh_token: refresh,
+            expires_at: Date.now() + expiresInSec * 1000
+        };
+        // Validate tokens before saving
+        validateTokens(tokens);
+        await saveTokens(tokens, customerIdn);
+        logAuthEvent('info', 'Token refresh completed successfully', {
+            customerIdn: customerIdn || 'legacy',
+            expiresAt: new Date(tokens.expires_at).toISOString()
+        });
+        return tokens;
+    }
+    catch (error) {
+        logAuthEvent('error', 'Token refresh failed', {
+            customerIdn: customerIdn || 'legacy',
+            error: error instanceof Error ? error.message : String(error)
+        });
+        handleNetworkError(error, 'refresh token', customerIdn);
+    }
+}
+export async function getValidAccessToken(customer) {
+    const customerIdn = customer?.idn;
+    logAuthEvent('info', 'Getting valid access token', { customerIdn: customerIdn || 'legacy' });
+    try {
+        let tokens = await loadTokens(customerIdn);
+        // No tokens found, exchange API key
+        if (!tokens || !tokens.access_token) {
+            logAuthEvent('info', 'No existing tokens found, exchanging API key', { customerIdn: customerIdn || 'legacy' });
+            tokens = await exchangeApiKeyForToken(customer);
+            return tokens.access_token;
+        }
+        // Tokens are valid and not expired
+        if (!isExpired(tokens)) {
+            logAuthEvent('info', 'Using existing valid access token', { customerIdn: customerIdn || 'legacy' });
+            return tokens.access_token;
+        }
+        // Try to refresh if refresh URL and token available
+        if (ENV.NEWO_REFRESH_URL && tokens.refresh_token) {
+            try {
+                logAuthEvent('info', 'Attempting to refresh expired token', { customerIdn: customerIdn || 'legacy' });
+                tokens = await refreshWithEndpoint(tokens.refresh_token, customer);
+                return tokens.access_token;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                logAuthEvent('warn', 'Token refresh failed, falling back to API key exchange', {
+                    customerIdn: customerIdn || 'legacy',
+                    error: message
+                });
+            }
+        }
+        else {
+            logAuthEvent('info', 'No refresh endpoint or refresh token available, using API key exchange', {
+                customerIdn: customerIdn || 'legacy'
+            });
+        }
+        // Fallback to API key exchange
+        tokens = await exchangeApiKeyForToken(customer);
+        return tokens.access_token;
+    }
+    catch (error) {
+        logAuthEvent('error', 'Failed to get valid access token', {
+            customerIdn: customerIdn || 'legacy',
+            error: error instanceof Error ? error.message : String(error)
+        });
+        throw new Error(`Unable to obtain valid access token${customerIdn ? ` for customer ${customerIdn}` : ''}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function forceReauth(customer) {
+    const customerIdn = customer?.idn;
+    logAuthEvent('info', 'Forcing re-authentication', { customerIdn: customerIdn || 'legacy' });
+    try {
+        const tokens = await exchangeApiKeyForToken(customer);
+        logAuthEvent('info', 'Forced re-authentication completed successfully', {
+            customerIdn: customerIdn || 'legacy',
+            expiresAt: new Date(tokens.expires_at).toISOString()
+        });
+        return tokens.access_token;
+    }
+    catch (error) {
+        logAuthEvent('error', 'Forced re-authentication failed', {
+            customerIdn: customerIdn || 'legacy',
+            error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+    }
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+import minimist from 'minimist';
+import dotenv from 'dotenv';
+import { makeClient, getProjectMeta, importAkbArticle } from './api.js';
+import { pullAll, pushChanged, status } from './sync.js';
+import { parseAkbFile, prepareArticlesForImport } from './akb.js';
+import { initializeEnvironment, ENV, EnvValidationError } from './env.js';
+import { parseCustomerConfigAsync, listCustomers, getCustomer, getDefaultCustomer, validateCustomerConfig } from './customerAsync.js';
+import { getValidAccessToken } from './auth.js';
+import path from 'path';
+// Enhanced error logging for CLI
+function logCliError(level, message, meta) {
+    const timestamp = new Date().toISOString();
+    const logEntry = {
+        timestamp,
+        level,
+        module: 'cli',
+        message,
+        ...meta
+    };
+    // Only log JSON format in verbose mode, otherwise use clean user messages
+    const verbose = process.argv.includes('--verbose') || process.argv.includes('-v');
+    if (verbose) {
+        if (level === 'error') {
+            console.error(JSON.stringify(logEntry));
+        }
+        else if (level === 'warn') {
+            console.warn(JSON.stringify(logEntry));
+        }
+        else {
+            console.log(JSON.stringify(logEntry));
+        }
+    }
+    else {
+        // Clean user-facing messages
+        if (level === 'error') {
+            console.error(`❌ ${message}`);
+        }
+        else if (level === 'warn') {
+            console.warn(`⚠️  ${message}`);
+        }
+        else {
+            console.log(`ℹ️  ${message}`);
+        }
+    }
+}
+// Enhanced error handling with user-friendly messages  
+function handleCliError(error, operation = 'operation') {
+    const verbose = process.argv.includes('--verbose') || process.argv.includes('-v');
+    if (error instanceof Error) {
+        // Authentication errors
+        if (error.message.includes('API key') || error.message.includes('Authentication failed')) {
+            logCliError('error', 'Authentication failed. Please check your API key configuration.');
+            if (!verbose) {
+                console.error('\n💡 Troubleshooting tips:');
+                console.error('  • Verify your API key is correct in .env file');
+                console.error('  • For multi-customer setup, check NEWO_CUSTOMER_<IDN>_API_KEY');
+                console.error('  • Run with --verbose for detailed error information');
+            }
+        }
+        // Network errors
+        else if (error.message.includes('Network timeout') || error.message.includes('ENOTFOUND') || error.message.includes('ECONNREFUSED')) {
+            logCliError('error', 'Network connection failed. Please check your internet connection.');
+            if (!verbose) {
+                console.error('\n💡 Troubleshooting tips:');
+                console.error('  • Check your internet connection');
+                console.error('  • Verify NEWO_BASE_URL is correct');
+                console.error('  • Try again in a few moments');
+            }
+        }
+        // Environment configuration errors
+        else if (error instanceof EnvValidationError || error.message.includes('not set')) {
+            logCliError('error', 'Configuration error. Please check your environment setup.');
+            if (!verbose) {
+                console.error('\n💡 Setup help:');
+                console.error('  • Copy .env.example to .env and configure your settings');
+                console.error('  • Run "newo --help" to see configuration examples');
+                console.error('  • Check the README for detailed setup instructions');
+            }
+        }
+        // File system errors
+        else if (error.message.includes('ENOENT') || error.message.includes('EACCES')) {
+            logCliError('error', 'File system error. Please check file permissions and paths.');
+        }
+        // Rate limiting
+        else if (error.message.includes('Rate limit exceeded')) {
+            logCliError('error', 'Rate limit exceeded. Please wait before trying again.');
+        }
+        // General API errors
+        else if (error.message.includes('response') || error.message.includes('status')) {
+            logCliError('error', `API error during ${operation}. Please try again or contact support.`);
+        }
+        // Unknown errors
+        else {
+            logCliError('error', `Unexpected error during ${operation}: ${error.message}`);
+            if (!verbose) {
+                console.error('\n💡 For more details, run the command with --verbose flag');
+            }
+        }
+        if (verbose) {
+            logCliError('error', 'Full error details', {
+                operation,
+                errorType: error.constructor.name,
+                stack: error.stack?.split('\n').slice(0, 5).join('\n') // First 5 lines of stack
+            });
+        }
+    }
+    else {
+        logCliError('error', `Unknown error during ${operation}: ${String(error)}`);
+    }
+    process.exit(1);
+}
+dotenv.config();
+async function main() {
+    try {
+        // Initialize and validate environment at startup
+        initializeEnvironment();
+    }
+    catch (error) {
+        if (error instanceof EnvValidationError) {
+            console.error('Environment validation failed:', error.message);
+            process.exit(1);
+        }
+        throw error;
+    }
+    const args = minimist(process.argv.slice(2));
+    const cmd = args._[0];
+    const verbose = Boolean(args.verbose || args.v);
+    // Parse customer configuration (async for API key array support)  
+    let customerConfig;
+    try {
+        customerConfig = await parseCustomerConfigAsync(ENV, verbose);
+        validateCustomerConfig(customerConfig);
+    }
+    catch (error) {
+        logCliError('error', 'Failed to parse customer configuration');
+        if (error instanceof Error) {
+            logCliError('error', error.message);
+        }
+        process.exit(1);
+    }
+    // Handle customer selection
+    let selectedCustomer;
+    if (cmd === 'list-customers') {
+        const customers = listCustomers(customerConfig);
+        console.log('Available customers:');
+        for (const customerIdn of customers) {
+            const isDefault = customerConfig.defaultCustomer === customerIdn;
+            console.log(`  ${customerIdn}${isDefault ? ' (default)' : ''}`);
+        }
+        return;
+    }
+    if (args.customer) {
+        const customer = getCustomer(customerConfig, args.customer);
+        if (!customer) {
+            console.error(`Unknown customer: ${args.customer}`);
+            console.error(`Available customers: ${listCustomers(customerConfig).join(', ')}`);
+            process.exit(1);
+        }
+        selectedCustomer = customer;
+    }
+    else {
+        try {
+            selectedCustomer = getDefaultCustomer(customerConfig);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(message);
+            process.exit(1);
+        }
+    }
+    if (!cmd || ['help', '-h', '--help'].includes(cmd)) {
+        console.log(`NEWO CLI - Multi-Customer Support
+Usage:
+  newo pull [--customer <idn>]                  # download projects -> ./newo_customers/<idn>/projects/
+  newo push [--customer <idn>]                  # upload modified *.guidance/*.jinja back to NEWO
+  newo status [--customer <idn>]                # show modified files
+  newo list-customers                           # list available customers
+  newo meta [--customer <idn>]                  # get project metadata (debug)
+  newo import-akb <file> <persona_id> [--customer <idn>]  # import AKB articles from file
+  
+Flags:
+  --customer <idn>             # specify customer (if not set, uses default)
+  --verbose, -v                # enable detailed logging
+  
+Environment Variables:
+  NEWO_BASE_URL                                 # NEWO API base URL (default: https://app.newo.ai)
+  NEWO_CUSTOMER_<IDN>_API_KEY                   # API key for customer <IDN>
+  NEWO_CUSTOMER_<IDN>_PROJECT_ID               # Optional: specific project ID for customer
+  NEWO_DEFAULT_CUSTOMER                        # Optional: default customer to use
+  
+Multi-Customer Examples:
+  # Configure customers in .env:
+  NEWO_CUSTOMER_acme_API_KEY=your_acme_api_key
+  NEWO_CUSTOMER_globex_API_KEY=your_globex_api_key
+  NEWO_DEFAULT_CUSTOMER=acme
+  
+  # Commands:
+  newo pull --customer acme                    # Pull projects for Acme
+  newo push --customer globex                  # Push changes for Globex
+  newo status                                  # Status for default customer
+  
+File Structure:
+  newo_customers/
+  ├── acme/
+  │   └── projects/
+  │       └── project1/
+  └── globex/
+      └── projects/
+          └── project2/
+`);
+        return;
+    }
+    // Get access token for the selected customer
+    const accessToken = await getValidAccessToken(selectedCustomer);
+    const client = await makeClient(verbose, accessToken);
+    if (cmd === 'pull') {
+        // Use customer-specific project ID if set, otherwise pull all projects
+        const projectId = selectedCustomer.projectId || null;
+        await pullAll(client, selectedCustomer, projectId, verbose);
+    }
+    else if (cmd === 'push') {
+        await pushChanged(client, selectedCustomer, verbose);
+    }
+    else if (cmd === 'status') {
+        await status(selectedCustomer, verbose);
+    }
+    else if (cmd === 'meta') {
+        if (!selectedCustomer.projectId) {
+            console.error(`No project ID configured for customer ${selectedCustomer.idn}`);
+            console.error(`Set NEWO_CUSTOMER_${selectedCustomer.idn.toUpperCase()}_PROJECT_ID in your .env file`);
+            process.exit(1);
+        }
+        const meta = await getProjectMeta(client, selectedCustomer.projectId);
+        console.log(JSON.stringify(meta, null, 2));
+    }
+    else if (cmd === 'import-akb') {
+        const akbFile = args._[1];
+        const personaId = args._[2];
+        if (!akbFile || !personaId) {
+            console.error('Usage: newo import-akb <file> <persona_id>');
+            console.error('Example: newo import-akb akb.txt da4550db-2b95-4500-91ff-fb4b60fe7be9');
+            process.exit(1);
+        }
+        const filePath = path.resolve(akbFile);
+        try {
+            if (verbose)
+                console.log(`📖 Parsing AKB file: ${filePath}`);
+            const articles = await parseAkbFile(filePath);
+            console.log(`✓ Parsed ${articles.length} articles from ${akbFile}`);
+            if (verbose)
+                console.log(`🔧 Preparing articles for persona: ${personaId}`);
+            const preparedArticles = prepareArticlesForImport(articles, personaId);
+            let successCount = 0;
+            let errorCount = 0;
+            console.log(`📤 Importing ${preparedArticles.length} articles...`);
+            for (const [index, article] of preparedArticles.entries()) {
+                try {
+                    if (verbose) {
+                        console.log(`  [${index + 1}/${preparedArticles.length}] Importing ${article.topic_name}...`);
+                    }
+                    await importAkbArticle(client, article);
+                    successCount++;
+                    if (!verbose)
+                        process.stdout.write('.');
+                }
+                catch (error) {
+                    errorCount++;
+                    const errorMessage = error instanceof Error && 'response' in error
+                        ? error?.response?.data
+                        : error instanceof Error
+                            ? error.message
+                            : String(error);
+                    console.error(`\n❌ Failed to import ${article.topic_name}:`, errorMessage);
+                }
+            }
+            if (!verbose)
+                console.log(''); // new line after dots
+            console.log(`✅ Import complete: ${successCount} successful, ${errorCount} failed`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error('❌ AKB import failed:', message);
+            process.exit(1);
+        }
+    }
+    else {
+        console.error('Unknown command:', cmd);
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    // Determine operation context from command line args
+    const args = process.argv.slice(2);
+    const cmd = args.find(arg => !arg.startsWith('-')) || 'unknown command';
+    // Handle API errors with specific data
+    if (error instanceof Error && 'response' in error) {
+        const apiError = error;
+        const responseData = apiError.response?.data;
+        const status = apiError.response?.status;
+        if (responseData && status) {
+            logCliError('error', `API error (${status}): ${JSON.stringify(responseData)}`);
+        }
+    }
+    handleCliError(error, cmd);
+});
+//# sourceMappingURL=cli.js.map