carto-cli 0.1.0-rc.1

package/dist/config.js

@@ -0,0 +1,320 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentProfile = getCurrentProfile;
+exports.setCurrentProfile = setCurrentProfile;
+exports.suggestProfileName = suggestProfileName;
+exports.loadCredentials = loadCredentials;
+exports.loadAllCredentials = loadAllCredentials;
+exports.listProfileNames = listProfileNames;
+exports.saveCredentials = saveCredentials;
+exports.deleteCredentials = deleteCredentials;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.deleteConfig = deleteConfig;
+exports.getApiToken = getApiToken;
+exports.fetchTenantConfig = fetchTenantConfig;
+exports.getTenantId = getTenantId;
+exports.getLiteLLMUrl = getLiteLLMUrl;
+exports.getAllUrls = getAllUrls;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const http_1 = require("./http");
+// In-memory cache for tenant config (per process)
+const tenantConfigCache = new Map();
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.carto');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+const CREDENTIALS_FILE = path_1.default.join(os_1.default.homedir(), '.carto_credentials.json');
+// Migrate old credentials file format to new format
+function migrateCredentialsFile(data) {
+    // Check if already in new format
+    if (data.profiles !== undefined) {
+        return data;
+    }
+    // Old format: profiles are at root level
+    // Migrate to new format with current_profile and profiles structure
+    const migratedProfiles = {};
+    for (const [profileName, creds] of Object.entries(data)) {
+        // Only migrate if it looks like a profile (has token field)
+        if (typeof creds === 'object' && creds !== null && 'token' in creds) {
+            const oldCreds = creds;
+            migratedProfiles[profileName] = {
+                token: oldCreds.token,
+                tenant_id: oldCreds.tenant_id,
+                tenant_domain: oldCreds.tenant_domain,
+                // For old profiles, we don't have this info
+                organization_id: oldCreds.organization_id || '',
+                organization_name: oldCreds.organization_name || '',
+                user_email: oldCreds.user_email || '',
+            };
+        }
+    }
+    return {
+        current_profile: 'default', // Default to 'default' profile for backwards compatibility
+        profiles: migratedProfiles,
+    };
+}
+// Load all credentials with migration
+function loadCredentialsFile() {
+    try {
+        if (fs_1.default.existsSync(CREDENTIALS_FILE)) {
+            const data = fs_1.default.readFileSync(CREDENTIALS_FILE, 'utf-8');
+            const parsed = JSON.parse(data);
+            const migrated = migrateCredentialsFile(parsed);
+            // Save migrated format if it was changed
+            if (parsed.profiles === undefined && Object.keys(migrated.profiles).length > 0) {
+                fs_1.default.writeFileSync(CREDENTIALS_FILE, JSON.stringify(migrated, null, 2), 'utf-8');
+            }
+            return migrated;
+        }
+    }
+    catch (error) {
+        // Ignore errors, return empty structure
+    }
+    return { profiles: {} };
+}
+// Get current profile name with fallbacks
+function getCurrentProfile() {
+    // Priority: CARTO_PROFILE env var > current_profile field > 'default'
+    if (process.env.CARTO_PROFILE) {
+        return process.env.CARTO_PROFILE;
+    }
+    const file = loadCredentialsFile();
+    return file.current_profile || 'default';
+}
+// Set current profile
+function setCurrentProfile(profileName) {
+    const file = loadCredentialsFile();
+    // Verify profile exists
+    if (!file.profiles[profileName]) {
+        throw new Error(`Profile '${profileName}' not found`);
+    }
+    file.current_profile = profileName;
+    fs_1.default.writeFileSync(CREDENTIALS_FILE, JSON.stringify(file, null, 2), 'utf-8');
+}
+// Generate suggested profile name
+function suggestProfileName(credentials) {
+    const parts = [];
+    // Add auth environment prefix only for non-production
+    if (credentials.auth_environment && credentials.auth_environment !== 'production') {
+        parts.push(credentials.auth_environment);
+    }
+    if (credentials.tenant_id) {
+        parts.push(credentials.tenant_id);
+    }
+    if (credentials.organization_name) {
+        parts.push(credentials.organization_name);
+    }
+    if (credentials.user_email) {
+        parts.push(credentials.user_email);
+    }
+    return parts.join('/');
+}
+// Load specific profile credentials
+function loadCredentials(profileName) {
+    try {
+        const file = loadCredentialsFile();
+        const targetProfile = profileName || getCurrentProfile();
+        return file.profiles[targetProfile] || null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+// Load all credentials
+function loadAllCredentials() {
+    return loadCredentialsFile();
+}
+// Get list of profile names
+function listProfileNames() {
+    const file = loadCredentialsFile();
+    return Object.keys(file.profiles);
+}
+// Save credentials for a profile
+function saveCredentials(profileName, credentials, setAsCurrent = true) {
+    try {
+        const file = loadCredentialsFile();
+        // Add or update the profile
+        file.profiles[profileName] = credentials;
+        // Set as current if requested or if it's the first profile
+        if (setAsCurrent || Object.keys(file.profiles).length === 1) {
+            file.current_profile = profileName;
+        }
+        fs_1.default.writeFileSync(CREDENTIALS_FILE, JSON.stringify(file, null, 2), 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to save credentials: ${error}`);
+    }
+}
+// Delete credentials for a profile
+function deleteCredentials(profileName) {
+    try {
+        const file = loadCredentialsFile();
+        if (!file.profiles[profileName]) {
+            throw new Error(`Profile '${profileName}' not found`);
+        }
+        delete file.profiles[profileName];
+        // If we deleted the current profile, switch to another one or clear
+        if (file.current_profile === profileName) {
+            const remainingProfiles = Object.keys(file.profiles);
+            file.current_profile = remainingProfiles.length > 0 ? remainingProfiles[0] : undefined;
+        }
+        // If no profiles left, delete the file
+        if (Object.keys(file.profiles).length === 0) {
+            fs_1.default.unlinkSync(CREDENTIALS_FILE);
+        }
+        else {
+            fs_1.default.writeFileSync(CREDENTIALS_FILE, JSON.stringify(file, null, 2), 'utf-8');
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to delete credentials: ${error}`);
+    }
+}
+// Legacy config file functions (kept for backwards compatibility)
+function loadConfig() {
+    try {
+        if (fs_1.default.existsSync(CONFIG_FILE)) {
+            const data = fs_1.default.readFileSync(CONFIG_FILE, 'utf-8');
+            return JSON.parse(data);
+        }
+    }
+    catch (error) {
+        // Ignore errors, return empty config
+    }
+    return {};
+}
+function saveConfig(config) {
+    try {
+        if (!fs_1.default.existsSync(CONFIG_DIR)) {
+            fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to save config: ${error}`);
+    }
+}
+function deleteConfig() {
+    try {
+        if (fs_1.default.existsSync(CONFIG_FILE)) {
+            fs_1.default.unlinkSync(CONFIG_FILE);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to delete config: ${error}`);
+    }
+}
+function getApiToken(profileName) {
+    // Priority: environment variable > credentials file > legacy config file
+    if (process.env.CARTO_API_TOKEN) {
+        return process.env.CARTO_API_TOKEN;
+    }
+    const credentials = loadCredentials(profileName);
+    if (credentials) {
+        return credentials.token;
+    }
+    return loadConfig().apiToken;
+}
+/**
+ * Fetch tenant configuration from config.yaml
+ * @param tenant_domain The tenant domain (e.g., "clausa-26.dev.app.carto.com")
+ * @returns Tenant configuration with API URLs
+ */
+async function fetchTenantConfig(tenant_domain) {
+    // Check cache first
+    if (tenantConfigCache.has(tenant_domain)) {
+        return tenantConfigCache.get(tenant_domain);
+    }
+    const configUrl = `https://${tenant_domain}/config.yaml`;
+    try {
+        const response = await (0, http_1.request)(configUrl, { method: 'GET' });
+        if (response.statusCode !== 200) {
+            throw new Error(`HTTP ${response.statusCode}: ${response.body}`);
+        }
+        // Parse YAML
+        const config = js_yaml_1.default.load(response.body);
+        if (!config || !config.apis) {
+            throw new Error('Invalid config.yaml format: missing apis section');
+        }
+        const tenantConfig = {
+            accountsUrl: config.apis.accountsUrl,
+            workspaceUrl: config.apis.workspaceUrl,
+            baseUrl: config.apis.baseUrl,
+            aiApi: config.apis.aiApi,
+        };
+        // Validate required fields
+        if (!tenantConfig.accountsUrl || !tenantConfig.workspaceUrl || !tenantConfig.baseUrl || !tenantConfig.aiApi) {
+            throw new Error('Invalid config.yaml: missing required API URLs');
+        }
+        // Cache the config
+        tenantConfigCache.set(tenant_domain, tenantConfig);
+        return tenantConfig;
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch tenant configuration from ${configUrl}: ${error.message}`);
+    }
+}
+/**
+ * Get validated tenant configuration
+ * Loads credentials, validates tenant_domain, and fetches config once
+ */
+async function getValidatedTenantConfig(profileName) {
+    const credentials = loadCredentials(profileName);
+    if (!credentials) {
+        throw new Error('Not authenticated. Please run: carto auth login');
+    }
+    if (!credentials.tenant_domain) {
+        throw new Error('Profile configuration incomplete: tenant_domain not found. Please re-authenticate with: carto auth login');
+    }
+    return await fetchTenantConfig(credentials.tenant_domain);
+}
+async function getTenantId(profileName) {
+    const credentials = loadCredentials(profileName);
+    if (!credentials) {
+        throw new Error('Not authenticated. Please run: carto auth login');
+    }
+    return credentials.tenant_id;
+}
+// TODO: LiteLLM URL is not available in config.yaml
+// Keep using hardcoded construction for now
+function getLiteLLMUrl(profileName) {
+    const credentials = loadCredentials(profileName);
+    if (credentials) {
+        return `https://litellm-${credentials.tenant_id}.api.carto.com`;
+    }
+    return 'https://litellm-gcp-us-east1.api.carto.com';
+}
+/**
+ * Helper function to get all URLs at once for ApiClient
+ * Returns URLs from config.yaml if tenant_domain is available
+ */
+async function getAllUrls(profileName) {
+    const credentials = loadCredentials(profileName);
+    // For M2M profiles with base_url set directly, skip tenant config lookup
+    if (credentials?.base_url) {
+        // Extract region from base_url (e.g., "gcp-us-east1" from "https://gcp-us-east1.api.carto.com")
+        const regionMatch = credentials.base_url.match(/https:\/\/([^.]+)\.api\.carto\.com/);
+        const region = regionMatch ? regionMatch[1] : 'gcp-us-east1';
+        return {
+            baseUrl: credentials.base_url,
+            workspaceUrl: `https://workspace-${region}.app.carto.com`,
+            accountsUrl: 'https://accounts.app.carto.com',
+            aiApiUrl: `https://ai-${region}.api.carto.com`,
+            litellmUrl: `https://litellm-${region}.api.carto.com`
+        };
+    }
+    const config = await getValidatedTenantConfig(profileName);
+    const litellmUrl = getLiteLLMUrl(profileName);
+    return {
+        baseUrl: config.baseUrl,
+        workspaceUrl: config.workspaceUrl,
+        accountsUrl: config.accountsUrl,
+        aiApiUrl: config.aiApi,
+        litellmUrl
+    };
+}

package/dist/download.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = downloadFile;
+exports.formatBytes = formatBytes;
+exports.getFilenameFromUrl = getFilenameFromUrl;
+exports.sanitizeFilename = sanitizeFilename;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Downloads a file from a URL to a local path
+ * @param url - The URL to download from
+ * @param outputPath - The local file path to save to
+ * @param onProgress - Optional callback for progress updates
+ */
+async function downloadFile(url, outputPath, onProgress) {
+    // Ensure output directory exists
+    const outputDir = path_1.default.dirname(outputPath);
+    if (!fs_1.default.existsSync(outputDir)) {
+        fs_1.default.mkdirSync(outputDir, { recursive: true });
+    }
+    return new Promise((resolve, reject) => {
+        const https = require('https');
+        const http = require('http');
+        const protocol = url.startsWith('https:') ? https : http;
+        protocol.get(url, (response) => {
+            if (response.statusCode === 301 || response.statusCode === 302) {
+                // Handle redirects
+                const redirectUrl = response.headers.location;
+                if (redirectUrl) {
+                    downloadFile(redirectUrl, outputPath, onProgress).then(resolve).catch(reject);
+                    return;
+                }
+            }
+            if (response.statusCode !== 200) {
+                reject(new Error(`Download failed with status ${response.statusCode}`));
+                return;
+            }
+            const totalSize = parseInt(response.headers['content-length'] || '0', 10);
+            let downloadedSize = 0;
+            const fileStream = fs_1.default.createWriteStream(outputPath);
+            response.on('data', (chunk) => {
+                downloadedSize += chunk.length;
+                if (onProgress && totalSize > 0) {
+                    const percentage = Math.round((downloadedSize / totalSize) * 100);
+                    onProgress({
+                        downloaded: downloadedSize,
+                        total: totalSize,
+                        percentage
+                    });
+                }
+            });
+            response.pipe(fileStream);
+            fileStream.on('finish', () => {
+                fileStream.close();
+                resolve();
+            });
+            fileStream.on('error', (err) => {
+                fs_1.default.unlinkSync(outputPath);
+                reject(err);
+            });
+            response.on('error', (err) => {
+                fs_1.default.unlinkSync(outputPath);
+                reject(err);
+            });
+        }).on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+/**
+ * Format bytes to human-readable string
+ */
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+}
+/**
+ * Extract filename from URL
+ */
+function getFilenameFromUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        const pathname = urlObj.pathname;
+        const filename = pathname.substring(pathname.lastIndexOf('/') + 1);
+        // Decode URL-encoded characters
+        return decodeURIComponent(filename);
+    }
+    catch (err) {
+        return 'downloaded_file';
+    }
+}
+/**
+ * Sanitize filename to make it safe for filesystem
+ */
+function sanitizeFilename(filename) {
+    // Remove or replace unsafe characters
+    return filename
+        .replace(/[<>:"/\\|?*\x00-\x1F]/g, '_')
+        .replace(/\s+/g, '_')
+        .substring(0, 255); // Limit length
+}