carto-cli 0.1.0-rc.1

package/dist/commands/maps.js

@@ -0,0 +1,1022 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapsList = mapsList;
+exports.mapsGet = mapsGet;
+exports.mapsDelete = mapsDelete;
+exports.mapsCopy = mapsCopy;
+exports.mapsCreate = mapsCreate;
+exports.mapsUpdate = mapsUpdate;
+exports.mapsClone = mapsClone;
+const api_1 = require("../api");
+const colors_1 = require("../colors");
+const fs_1 = require("fs");
+const prompt_1 = require("../prompt");
+async function mapsList(options, token, baseUrl, jsonOutput, debug = false, profile) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        let result;
+        let userId;
+        // If --mine flag is set, get current user ID
+        if (options.mine) {
+            const userInfo = await client.getAccounts('/users/me', true);
+            userId = userInfo.user_id;
+        }
+        if (options.all) {
+            // Fetch all pages automatically using Workspace API
+            const baseParams = {};
+            if (options.orderBy)
+                baseParams['order_by'] = options.orderBy;
+            if (options.orderDirection)
+                baseParams['order_direction'] = options.orderDirection;
+            if (options.search)
+                baseParams['search'] = options.search;
+            if (options.privacy)
+                baseParams['privacy'] = options.privacy;
+            if (options.tags)
+                baseParams['tags'] = JSON.stringify(options.tags);
+            if (userId)
+                baseParams['user_id'] = userId;
+            const paginatedResult = await client.getAllPaginatedWorkspace('/maps', baseParams);
+            result = {
+                data: paginatedResult.data,
+                meta: {
+                    page: {
+                        total: paginatedResult.total,
+                        current: 1,
+                        pageSize: paginatedResult.total,
+                        totalPages: 1
+                    }
+                }
+            };
+        }
+        else {
+            // Fetch single page using Workspace API
+            const params = new URLSearchParams();
+            if (options.orderBy)
+                params.append('order_by', options.orderBy);
+            if (options.orderDirection)
+                params.append('order_direction', options.orderDirection);
+            if (options.pageSize)
+                params.append('page_size', options.pageSize);
+            if (options.page)
+                params.append('page', options.page);
+            if (options.search)
+                params.append('search', options.search);
+            if (options.privacy)
+                params.append('privacy', options.privacy);
+            if (options.tags)
+                params.append('tags', JSON.stringify(options.tags));
+            if (userId)
+                params.append('user_id', userId);
+            const queryString = params.toString();
+            const path = `/maps${queryString ? '?' + queryString : ''}`;
+            result = await client.getWorkspace(path);
+        }
+        if (jsonOutput) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            const maps = result.data || result.results || result;
+            const total = result.meta?.page?.total || result.total || maps.length;
+            const currentPage = result.meta?.page?.current || result.page || 1;
+            const pageSize = result.meta?.page?.pageSize || result.page_size || 12;
+            const totalPages = result.meta?.page?.totalPages || Math.ceil(total / pageSize);
+            // Display header with search query if present
+            const header = options.search
+                ? `\n${total} maps found for '${options.search}':\n`
+                : `\nMaps (${total}):\n`;
+            console.log((0, colors_1.bold)(header));
+            maps.forEach((map) => {
+                console.log((0, colors_1.bold)('Map ID: ') + map.id);
+                console.log('  Name: ' + (map.title || '(Untitled)'));
+                console.log('  Owner: ' + (map.ownerEmail || 'N/A'));
+                console.log('  Privacy: ' + (map.privacy || 'N/A'));
+                console.log('  Views: ' + (map.views !== undefined ? map.views : 'N/A'));
+                if (map.collaborative)
+                    console.log('  Collaborative: Yes');
+                if (map.tags && map.tags.length > 0) {
+                    console.log('  Tags: ' + map.tags.join(', '));
+                }
+                console.log('  Created: ' + new Date(map.createdAt || map.created_at).toLocaleString());
+                console.log('  Updated: ' + new Date(map.updatedAt || map.updated_at).toLocaleString());
+                console.log('');
+            });
+            if (options.all) {
+                console.log((0, colors_1.dim)(`Fetched all ${total} maps`));
+            }
+            else if (totalPages > 1) {
+                console.log((0, colors_1.dim)(`Page ${currentPage} of ${totalPages} (use --all to fetch all pages)`));
+            }
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else {
+                console.log((0, colors_1.error)('✗ Failed to list maps: ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+}
+async function mapsGet(mapId, token, baseUrl, jsonOutput, debug = false, profile) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        // Fetch map details and datasets from Workspace API
+        const map = await client.getWorkspace(`/maps/${mapId}`);
+        const datasets = await client.getWorkspace(`/maps/${mapId}/datasets`);
+        if (jsonOutput) {
+            console.log(JSON.stringify({ map, datasets }));
+        }
+        else {
+            // Display map metadata
+            console.log((0, colors_1.bold)('\n=== Map Details ===\n'));
+            console.log((0, colors_1.bold)('ID: ') + map.id);
+            console.log((0, colors_1.bold)('Title: ') + (map.title || '(Untitled)'));
+            if (map.description)
+                console.log((0, colors_1.bold)('Description: ') + map.description);
+            console.log((0, colors_1.bold)('Owner: ') + (map.ownerEmail || 'N/A'));
+            console.log((0, colors_1.bold)('Privacy: ') + (map.privacy || 'N/A'));
+            console.log((0, colors_1.bold)('Views: ') + (map.views !== undefined ? map.views : 'N/A'));
+            console.log((0, colors_1.bold)('Collaborative: ') + (map.collaborative ? 'Yes' : 'No'));
+            console.log((0, colors_1.bold)('Agent Enabled: ') + (map.agentEnabled || map.agent?.enabledForViewer ? 'Yes' : 'No'));
+            if (map.publishedWithPassword)
+                console.log((0, colors_1.bold)('Password Protected: ') + 'Yes');
+            if (map.sharingScope)
+                console.log((0, colors_1.bold)('Sharing Scope: ') + map.sharingScope);
+            // Tags
+            if (map.tags && map.tags.length > 0) {
+                console.log((0, colors_1.bold)('Tags: ') + map.tags.join(', '));
+            }
+            // Timestamps
+            console.log((0, colors_1.bold)('Created: ') + new Date(map.createdAt).toLocaleString());
+            console.log((0, colors_1.bold)('Updated: ') + new Date(map.updatedAt).toLocaleString());
+            // Datasets and Connections
+            if (datasets && datasets.length > 0) {
+                console.log((0, colors_1.bold)(`\n=== Datasets (${datasets.length}) ===\n`));
+                // Extract unique connections
+                const connectionsMap = new Map();
+                datasets.forEach((ds) => {
+                    if (ds.connectionId && ds.connectionName) {
+                        connectionsMap.set(ds.connectionId, {
+                            id: ds.connectionId,
+                            name: ds.connectionName
+                        });
+                    }
+                });
+                // Display connections
+                if (connectionsMap.size > 0) {
+                    console.log((0, colors_1.bold)('Connections used:'));
+                    connectionsMap.forEach((conn) => {
+                        console.log(`  • ${conn.name} (${conn.id})`);
+                    });
+                    console.log('');
+                }
+                // Display datasets
+                console.log((0, colors_1.bold)('Datasets:'));
+                datasets.forEach((ds, idx) => {
+                    console.log(`  ${idx + 1}. ${(0, colors_1.bold)(ds.label || ds.name || ds.id)}`);
+                    console.log(`     Connection: ${ds.connectionName || 'N/A'}`);
+                    if (ds.source)
+                        console.log(`     Source: ${ds.source}`);
+                    if (ds.type)
+                        console.log(`     Type: ${ds.type}`);
+                    console.log('');
+                });
+            }
+            else {
+                console.log((0, colors_1.dim)('\nNo datasets found for this map'));
+            }
+            // Map URL
+            const mapUrl = `${client.workspaceUrl}/map/${mapId}`;
+            console.log((0, colors_1.bold)('Map URL: ') + mapUrl);
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else if (err.message.includes('404')) {
+                console.log((0, colors_1.error)('✗ Map not found: ' + mapId));
+            }
+            else {
+                console.log((0, colors_1.error)('✗ Failed to get map: ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+}
+async function mapsDelete(mapId, token, baseUrl, jsonOutput, debug = false, profile, yes) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        // Skip confirmation if --yes or --json flag is set
+        const skipConfirmation = yes || jsonOutput;
+        if (!skipConfirmation) {
+            // Fetch map details to show in confirmation prompt
+            let mapDetails;
+            try {
+                mapDetails = await client.getWorkspace(`/maps/${mapId}`);
+            }
+            catch (err) {
+                // If we can't fetch details, proceed with generic message
+                console.log((0, colors_1.warning)('\n⚠️  Warning: This will permanently delete this map.'));
+                console.log((0, colors_1.warning)(`   Map ID: ${mapId}`));
+            }
+            if (mapDetails) {
+                console.log((0, colors_1.warning)('\n⚠️  Warning: This will permanently delete:'));
+                console.log(`   Map: "${mapDetails.title || '(Untitled)'}"`);
+                console.log(`   ID: ${mapId}`);
+                if (mapDetails.ownerEmail) {
+                    console.log(`   Owner: ${mapDetails.ownerEmail}`);
+                }
+                if (mapDetails.privacy) {
+                    console.log(`   Privacy: ${mapDetails.privacy}`);
+                }
+            }
+            console.log('');
+            const confirmed = await (0, prompt_1.promptForConfirmation)("Type 'delete' to confirm: ", 'delete');
+            if (!confirmed) {
+                console.log('\nDeletion cancelled');
+                process.exit(0);
+            }
+            console.log('');
+        }
+        await client.delete(`/v3/organization-maps/${mapId}`);
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: true, message: 'Map deleted successfully', id: mapId }));
+        }
+        else {
+            console.log((0, colors_1.success)(`✓ Map ${mapId} deleted successfully`));
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            console.log((0, colors_1.error)('✗ Failed to delete map: ' + err.message));
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Check if CartoAI is enabled in the destination account
+ * Returns true if enabled, false otherwise
+ */
+async function checkCartoAIEnabled(client, jsonOutput) {
+    try {
+        const settings = await client.getWorkspace('/settings/carto-ai');
+        return settings?.enabled === true;
+    }
+    catch (err) {
+        // If endpoint doesn't exist or returns error, assume not enabled
+        if (!jsonOutput) {
+            // Only log in debug mode, don't pollute normal output
+        }
+        return false;
+    }
+}
+/**
+ * Copy agent configuration from source map to destination map
+ * Uses PATCH /maps/:id endpoint which properly checks CartoAI settings
+ */
+async function copyMapAgent(sourceClient, destClient, sourceMapId, destMapId, datasetsMapping, jsonOutput) {
+    try {
+        // Get source map to extract agent field
+        const sourceMap = await sourceClient.getWorkspace(`/maps/${sourceMapId}`);
+        if (!sourceMap.agent || !sourceMap.agent.config) {
+            // No agent configured in source
+            return false;
+        }
+        // Clone agent configuration
+        const agentConfig = JSON.parse(JSON.stringify(sourceMap.agent));
+        // Replace dataset IDs in agent config if needed (some agent configs may reference datasets)
+        let agentConfigStr = JSON.stringify(agentConfig);
+        for (const [oldId, newId] of Object.entries(datasetsMapping)) {
+            agentConfigStr = agentConfigStr.replace(new RegExp(oldId, 'g'), newId);
+        }
+        const updatedAgentConfig = JSON.parse(agentConfigStr);
+        // Update destination map with agent configuration
+        // Backend will handle:
+        // - CartoAI settings validation via ModelsService
+        // - Agent token creation
+        // - Workflow tool filtering
+        await destClient.patchWorkspace(`/maps/${destMapId}`, {
+            agent: updatedAgentConfig
+        });
+        return true;
+    }
+    catch (err) {
+        throw new Error(`Failed to copy agent: ${err.message}`);
+    }
+}
+/**
+ * Validate that a dataset source is accessible in the destination connection
+ * Uses dry-run SQL queries with WHERE 1=0 to test without transferring data
+ */
+async function validateDatasetSource(client, connectionName, dataset, jsonOutput) {
+    try {
+        let validationSQL;
+        // Build dry-run query based on dataset type
+        if (dataset.type === 'table') {
+            // For tables: SELECT * FROM table WHERE 1=0 LIMIT 1
+            validationSQL = `SELECT * FROM ${dataset.source} WHERE 1=0 LIMIT 1`;
+        }
+        else if (dataset.type === 'query') {
+            // For queries: wrap in subquery with WHERE 1=0
+            validationSQL = `SELECT * FROM (${dataset.source}) AS _validate WHERE 1=0`;
+        }
+        else {
+            // For tilesets or other types, treat as table
+            validationSQL = `SELECT * FROM ${dataset.source} WHERE 1=0 LIMIT 1`;
+        }
+        if (!jsonOutput) {
+            const displaySource = dataset.source.length > 60
+                ? dataset.source.substring(0, 57) + '...'
+                : dataset.source;
+            console.log((0, colors_1.dim)(`  ✓ ${dataset.label || dataset.name || 'Unnamed'} → ${displaySource}`));
+        }
+        // Execute validation query via SQL API
+        await client.post(`/v3/sql/${encodeURIComponent(connectionName)}/query`, {
+            q: validationSQL,
+            queryParameters: {}
+        });
+        // Success - source is accessible
+        return { accessible: true };
+    }
+    catch (err) {
+        // Extract meaningful error message from API response
+        let errorMsg = 'Unknown error';
+        if (err.message) {
+            errorMsg = err.message;
+            // Try to extract detail from API error JSON
+            try {
+                const match = err.message.match(/"detail":"([^"]+)"/);
+                if (match) {
+                    errorMsg = match[1];
+                }
+                else {
+                    // Try to extract just the main error message
+                    const errorMatch = err.message.match(/"error":"([^"]+)"/);
+                    if (errorMatch) {
+                        errorMsg = errorMatch[1];
+                    }
+                }
+            }
+            catch {
+                // Keep original error message if parsing fails
+            }
+        }
+        return {
+            accessible: false,
+            error: errorMsg
+        };
+    }
+}
+async function mapsCopy(mapId, connectionName, sourceProfile, destProfile, options, token, baseUrl, jsonOutput, debug = false) {
+    try {
+        // Step 1: Create API clients for source and destination
+        const sourceClient = await api_1.ApiClient.create(token, baseUrl, debug, sourceProfile);
+        const destClient = await api_1.ApiClient.create(token, baseUrl, debug, destProfile);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Copying map ${mapId} from ${sourceProfile} to ${destProfile}...`));
+        }
+        // Step 2: Fetch source map config and datasets
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('→ Fetching source map configuration...'));
+        }
+        const mapConfig = await sourceClient.getWorkspace(`/maps/${mapId}`);
+        const datasets = await sourceClient.getWorkspace(`/maps/${mapId}/datasets`);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`→ Found ${datasets.length} dataset(s) in source map`));
+        }
+        // Step 3: Parse connection mapping if provided
+        const manualMapping = {};
+        if (options.connectionMapping) {
+            const pairs = options.connectionMapping.split(',');
+            for (const pair of pairs) {
+                const [source, dest] = pair.split('=').map((s) => s.trim());
+                if (!source || !dest) {
+                    throw new Error(`Invalid connection mapping format: "${pair}". Use format: "source1=dest1,source2=dest2"`);
+                }
+                if (manualMapping[source]) {
+                    throw new Error(`Duplicate source connection in mapping: "${source}"`);
+                }
+                manualMapping[source] = dest;
+            }
+            // Check for circular mappings
+            const destValues = Object.values(manualMapping);
+            const duplicateDests = destValues.filter((item, index) => destValues.indexOf(item) !== index);
+            if (duplicateDests.length > 0) {
+                throw new Error(`Circular or duplicate destination mappings detected: ${duplicateDests.join(', ')}`);
+            }
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)(`→ Manual connection mapping: ${JSON.stringify(manualMapping)}`));
+            }
+        }
+        // Step 4: Collect unique source connections from datasets
+        const sourceConnectionsMap = new Map();
+        datasets.forEach((ds) => {
+            if (ds.connectionName) {
+                const existing = sourceConnectionsMap.get(ds.connectionName);
+                if (existing) {
+                    existing.datasetCount++;
+                }
+                else {
+                    sourceConnectionsMap.set(ds.connectionName, {
+                        id: ds.connectionId,
+                        name: ds.connectionName,
+                        datasetCount: 1
+                    });
+                }
+            }
+        });
+        if (!jsonOutput && sourceConnectionsMap.size > 0) {
+            console.log((0, colors_1.dim)(`→ Source map uses ${sourceConnectionsMap.size} connection(s):`));
+            sourceConnectionsMap.forEach((conn) => {
+                console.log((0, colors_1.dim)(`   • ${conn.name} (${conn.datasetCount} dataset${conn.datasetCount > 1 ? 's' : ''})`));
+            });
+        }
+        // Warn about mappings that reference non-existent source connections
+        if (Object.keys(manualMapping).length > 0) {
+            const sourceConnectionNames = Array.from(sourceConnectionsMap.keys());
+            for (const mappedSource of Object.keys(manualMapping)) {
+                if (!sourceConnectionNames.includes(mappedSource)) {
+                    if (!jsonOutput) {
+                        console.log((0, colors_1.error)(`⚠️  Warning: Mapping references "${mappedSource}" which is not used in source map`));
+                    }
+                }
+            }
+        }
+        // Step 5: Fetch all connections from destination
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('→ Fetching connections from destination...'));
+        }
+        const destConnections = await destClient.getWorkspace('/connections');
+        const destConnectionsByName = new Map();
+        destConnections.forEach((c) => {
+            destConnectionsByName.set(c.name, { id: c.id, name: c.name });
+        });
+        // Step 6: Resolve connections (manual mapping → auto-map by name → legacy single connection)
+        const connectionResolution = {};
+        const missingConnections = [];
+        for (const [sourceName, sourceInfo] of sourceConnectionsMap.entries()) {
+            let resolved = false;
+            // Try manual mapping first
+            if (manualMapping[sourceName]) {
+                const mappedDestName = manualMapping[sourceName];
+                const destConn = destConnectionsByName.get(mappedDestName);
+                if (destConn) {
+                    connectionResolution[sourceName] = {
+                        destName: mappedDestName,
+                        destId: destConn.id,
+                        method: 'manual'
+                    };
+                    resolved = true;
+                }
+                else {
+                    // Mapped connection doesn't exist in destination
+                    connectionResolution[sourceName] = {
+                        destName: mappedDestName,
+                        destId: null,
+                        method: 'missing'
+                    };
+                    missingConnections.push({ sourceName, datasetCount: sourceInfo.datasetCount });
+                    resolved = true;
+                }
+            }
+            // Try auto-map by name
+            if (!resolved) {
+                const destConn = destConnectionsByName.get(sourceName);
+                if (destConn) {
+                    connectionResolution[sourceName] = {
+                        destName: sourceName,
+                        destId: destConn.id,
+                        method: 'auto'
+                    };
+                    resolved = true;
+                }
+            }
+            // Legacy: use single --connection flag for ALL connections
+            if (!resolved && connectionName) {
+                const destConn = destConnectionsByName.get(connectionName);
+                if (destConn) {
+                    connectionResolution[sourceName] = {
+                        destName: connectionName,
+                        destId: destConn.id,
+                        method: 'legacy'
+                    };
+                    resolved = true;
+                }
+                else {
+                    throw new Error(`Legacy connection "${connectionName}" not found in destination organization`);
+                }
+            }
+            // Mark as missing if still not resolved
+            if (!resolved) {
+                connectionResolution[sourceName] = {
+                    destName: sourceName,
+                    destId: null,
+                    method: 'missing'
+                };
+                missingConnections.push({ sourceName, datasetCount: sourceInfo.datasetCount });
+            }
+        }
+        // Step 7: Display connection resolution results
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('→ Connection resolution:'));
+            for (const [sourceName, resolution] of Object.entries(connectionResolution)) {
+                if (resolution.method === 'manual') {
+                    console.log((0, colors_1.dim)(`   • ${sourceName} → ${resolution.destName} (manual mapping)`));
+                }
+                else if (resolution.method === 'auto') {
+                    console.log((0, colors_1.dim)(`   • ${sourceName} → ${resolution.destName} (auto-mapped)`));
+                }
+                else if (resolution.method === 'legacy') {
+                    console.log((0, colors_1.dim)(`   • ${sourceName} → ${resolution.destName} (legacy --connection)`));
+                }
+                else if (resolution.method === 'missing') {
+                    console.log((0, colors_1.error)(`   ✗ ${sourceName} → NOT FOUND`));
+                }
+            }
+        }
+        // Step 8: Check for missing connections and fail
+        if (missingConnections.length > 0) {
+            const errorMsg = [
+                'Missing connections in destination organization:',
+                ...missingConnections.map(mc => `  • "${mc.sourceName}" (used by ${mc.datasetCount} dataset${mc.datasetCount > 1 ? 's' : ''})`),
+                '',
+                'Solutions:',
+                '  1. Create missing connections in destination organization',
+                '  2. Use --connection-mapping to map to different connection names'
+            ].join('\n');
+            throw new Error(errorMsg);
+        }
+        // Step 8.5: Validate source accessibility (unless --skip-source-validation)
+        if (!options.skipSourceValidation) {
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)(`→ Validating ${datasets.length} dataset source(s)...`));
+            }
+            const inaccessibleDatasets = [];
+            for (const dataset of datasets) {
+                const sourceConnectionName = dataset.connectionName;
+                const resolution = connectionResolution[sourceConnectionName];
+                // Use the destination connection name for the SQL query
+                const destConnectionName = resolution.destName;
+                const result = await validateDatasetSource(destClient, destConnectionName, dataset, jsonOutput);
+                if (!result.accessible) {
+                    inaccessibleDatasets.push({
+                        label: dataset.label || dataset.name || 'Unnamed',
+                        source: dataset.source,
+                        error: result.error
+                    });
+                }
+            }
+            if (inaccessibleDatasets.length > 0) {
+                const errorMsg = [
+                    'Source validation failed - datasets cannot access their data sources:',
+                    ...inaccessibleDatasets.map(ds => `  • "${ds.label}" → ${ds.source}\n    Error: ${ds.error}`),
+                    '',
+                    'Solutions:',
+                    '  1. Grant access to these tables/views in destination connection',
+                    '  2. Ensure tables/views exist in destination data warehouse',
+                    '  3. Use --skip-source-validation to create map anyway (datasets will not load data)'
+                ].join('\n');
+                throw new Error(errorMsg);
+            }
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)(`→ All source(s) validated successfully`));
+            }
+        }
+        // Step 9: Create new map in destination
+        const newTitle = options.title || mapConfig.title;
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`→ Creating new map "${newTitle}" in destination...`));
+        }
+        const newMap = await destClient.postWorkspace('/maps', {
+            title: newTitle,
+        });
+        const newMapId = newMap.id;
+        if (!newMapId) {
+            throw new Error('Failed to create map in destination');
+        }
+        // Step 10: Create datasets in destination with resolved connections
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`→ Creating ${datasets.length} dataset(s) in destination...`));
+        }
+        const datasetsMapping = {};
+        for (const dataset of datasets) {
+            const sourceConnectionName = dataset.connectionName;
+            const resolution = connectionResolution[sourceConnectionName];
+            const newDataset = {
+                ...dataset,
+                connectionId: resolution.destId, // All connections are validated at this point
+                mapId: newMapId,
+            };
+            // Remove fields that shouldn't be copied
+            delete newDataset.id;
+            delete newDataset.connectionName;
+            delete newDataset.providerId;
+            delete newDataset.sourceWorkflowId;
+            delete newDataset.sourceWorkflowNodeId;
+            const createdDataset = await destClient.postWorkspace(`/maps/${newMapId}/datasets`, newDataset);
+            if (!createdDataset.id) {
+                throw new Error(`Failed to create dataset: ${dataset.name || dataset.label || 'unnamed'}`);
+            }
+            datasetsMapping[dataset.id] = createdDataset.id;
+        }
+        // Step 11: Update map configuration with new dataset IDs
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('→ Updating map configuration with new dataset IDs...'));
+        }
+        let updatedConfig = JSON.stringify(mapConfig.keplerMapConfig || {});
+        // Replace all old dataset IDs with new ones
+        for (const [oldId, newId] of Object.entries(datasetsMapping)) {
+            updatedConfig = updatedConfig.replace(new RegExp(oldId, 'g'), newId);
+        }
+        await destClient.patchWorkspace(`/maps/${newMapId}`, {
+            keplerMapConfig: JSON.parse(updatedConfig),
+        });
+        // Step 12: Set privacy if needed
+        if (options.keepPrivacy !== false && mapConfig.privacy === 'public') {
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)('→ Setting map privacy to public...'));
+            }
+            await destClient.postWorkspace(`/maps/${newMapId}/privacy`, {
+                privacy: 'public',
+            });
+        }
+        // Step 13: Copy agent configuration (if enabled and not skipped)
+        if (!options.skipAgent) {
+            // Check if carto-ai is enabled in destination
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)('→ Checking AI capabilities in destination...'));
+            }
+            const cartoAIEnabled = await checkCartoAIEnabled(destClient, jsonOutput);
+            if (!cartoAIEnabled) {
+                // CartoAI not enabled - skip gracefully with warning
+                if (!jsonOutput) {
+                    console.log((0, colors_1.warning)('⚠️  CartoAI not enabled in destination - skipping agent copy'));
+                    console.log((0, colors_1.dim)('    Enable CartoAI in destination account settings to copy AI agents'));
+                }
+            }
+            else {
+                // CartoAI is enabled, proceed with agent copy
+                if (!jsonOutput) {
+                    console.log((0, colors_1.dim)('→ Copying AI agent configuration...'));
+                }
+                try {
+                    const agentCopied = await copyMapAgent(sourceClient, destClient, mapId, newMapId, datasetsMapping, jsonOutput);
+                    if (agentCopied) {
+                        if (!jsonOutput) {
+                            console.log((0, colors_1.dim)('→ Agent copied successfully'));
+                        }
+                    }
+                    else {
+                        if (!jsonOutput) {
+                            console.log((0, colors_1.dim)('→ No agent configuration found'));
+                        }
+                    }
+                }
+                catch (err) {
+                    // Log agent copy failure as warning, but don't fail the whole operation
+                    if (!jsonOutput) {
+                        console.log((0, colors_1.warning)(`⚠️  Could not copy agent: ${err.message}`));
+                    }
+                }
+            }
+        }
+        else {
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)('→ Skipping agent configuration copy'));
+            }
+        }
+        // Get destination workspace URL for constructing map URL
+        const mapUrl = `${destClient.workspaceUrl}/map/${newMapId}`;
+        if (jsonOutput) {
+            console.log(JSON.stringify({
+                success: true,
+                sourceMapId: mapId,
+                newMapId: newMapId,
+                mapUrl: mapUrl,
+                sourceProfile: sourceProfile,
+                destProfile: destProfile,
+                datasetsCreated: datasets.length,
+                connectionResolution: connectionResolution,
+            }));
+        }
+        else {
+            console.log((0, colors_1.success)(`\n✓ Map copied successfully!`));
+            console.log((0, colors_1.bold)('New Map ID: ') + newMapId);
+            console.log((0, colors_1.bold)('Map URL: ') + mapUrl);
+            console.log((0, colors_1.dim)(`Datasets created: ${datasets.length}`));
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            console.log((0, colors_1.error)('✗ Failed to copy map: ' + err.message));
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Get JSON from various input sources (arg, file, stdin)
+ */
+async function getJsonFromInput(jsonString, options) {
+    let json = jsonString;
+    // Priority 1: --file flag
+    if (options.file) {
+        try {
+            json = (0, fs_1.readFileSync)(options.file, 'utf-8').trim();
+        }
+        catch (err) {
+            throw new Error(`Failed to read file: ${err.message}`);
+        }
+    }
+    // Priority 2: stdin
+    if (!json && !process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        json = Buffer.concat(chunks).toString('utf-8').trim();
+    }
+    // Parse JSON if we have it
+    if (!json) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(json);
+    }
+    catch (err) {
+        throw new Error(`Invalid JSON: ${err.message}`);
+    }
+}
+async function mapsCreate(jsonString, options, token, baseUrl, jsonOutput, debug = false, profile) {
+    try {
+        if (!jsonOutput) {
+            console.error((0, colors_1.dim)('⚠️  Note: maps create is experimental and subject to change\n'));
+        }
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        // Get map config from various sources
+        const config = await getJsonFromInput(jsonString, options);
+        if (!config) {
+            throw new Error('No map config provided. Use: carto maps create <json> or --file <path> or pipe via stdin');
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('Creating map...'));
+        }
+        // Step 1: Create the map with basic metadata
+        const mapPayload = {};
+        if (config.title)
+            mapPayload.title = config.title;
+        if (config.description)
+            mapPayload.description = config.description;
+        if (config.collaborative !== undefined)
+            mapPayload.collaborative = config.collaborative;
+        const newMap = await client.postWorkspace('/maps', mapPayload);
+        const newMapId = newMap.id;
+        if (!newMapId) {
+            throw new Error('Failed to create map');
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`→ Map created: ${newMapId}`));
+        }
+        // Step 2: Create datasets if provided
+        let datasetsCreated = 0;
+        if (config.datasets && Array.isArray(config.datasets)) {
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)(`→ Creating ${config.datasets.length} dataset(s)...`));
+            }
+            for (const dataset of config.datasets) {
+                // Get connection ID if connectionName is provided
+                let connectionId = dataset.connectionId;
+                if (!connectionId && dataset.connectionName) {
+                    const connections = await client.getWorkspace('/connections');
+                    const connection = connections.find((c) => c.name === dataset.connectionName);
+                    if (!connection) {
+                        throw new Error(`Connection "${dataset.connectionName}" not found`);
+                    }
+                    connectionId = connection.id;
+                }
+                const datasetPayload = {
+                    ...dataset,
+                    connectionId: connectionId,
+                    mapId: newMapId,
+                };
+                // Remove fields that shouldn't be sent
+                delete datasetPayload.connectionName;
+                delete datasetPayload.id;
+                await client.postWorkspace(`/maps/${newMapId}/datasets`, datasetPayload);
+                datasetsCreated++;
+            }
+        }
+        // Step 3: Update map with keplerMapConfig and agent if provided
+        const updatePayload = {};
+        if (config.keplerMapConfig)
+            updatePayload.keplerMapConfig = config.keplerMapConfig;
+        if (config.agent)
+            updatePayload.agent = config.agent;
+        if (config.tags)
+            updatePayload.tags = config.tags;
+        if (Object.keys(updatePayload).length > 0) {
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)('→ Updating map configuration...'));
+            }
+            await client.patchWorkspace(`/maps/${newMapId}`, updatePayload);
+        }
+        // Step 4: Set privacy if provided
+        if (config.privacy) {
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)(`→ Setting privacy to ${config.privacy}...`));
+            }
+            const privacyPayload = { privacy: config.privacy };
+            if (config.sharingScope) {
+                privacyPayload.sharingScope = config.sharingScope;
+            }
+            await client.postWorkspace(`/maps/${newMapId}/privacy`, privacyPayload);
+        }
+        // Get map URL
+        const mapUrl = `${client.workspaceUrl}/map/${newMapId}`;
+        if (jsonOutput) {
+            console.log(JSON.stringify({
+                success: true,
+                mapId: newMapId,
+                mapUrl: mapUrl,
+                datasetsCreated: datasetsCreated,
+            }));
+        }
+        else {
+            console.log((0, colors_1.success)('\n✓ Map created successfully!'));
+            console.log((0, colors_1.bold)('Map ID: ') + newMapId);
+            console.log((0, colors_1.bold)('Map URL: ') + mapUrl);
+            if (datasetsCreated > 0) {
+                console.log((0, colors_1.dim)(`Datasets created: ${datasetsCreated}`));
+            }
+            if (config.agent?.enabledForViewer) {
+                console.log((0, colors_1.dim)('Agent: enabled'));
+            }
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else {
+                console.log((0, colors_1.error)('✗ Failed to create map: ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+}
+async function mapsUpdate(mapId, jsonString, options, token, baseUrl, jsonOutput, debug = false, profile) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        // Get update config from various sources
+        const config = await getJsonFromInput(jsonString, options);
+        if (!config) {
+            throw new Error('No update config provided. Use: carto maps update <id> <json> or --file <path> or pipe via stdin');
+        }
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Updating map ${mapId}...`));
+        }
+        // Build update payload (can be partial)
+        const updatePayload = {};
+        if (config.title !== undefined)
+            updatePayload.title = config.title;
+        if (config.description !== undefined)
+            updatePayload.description = config.description;
+        if (config.collaborative !== undefined)
+            updatePayload.collaborative = config.collaborative;
+        if (config.keplerMapConfig)
+            updatePayload.keplerMapConfig = config.keplerMapConfig;
+        if (config.agent)
+            updatePayload.agent = config.agent;
+        if (config.tags)
+            updatePayload.tags = config.tags;
+        // Update the map
+        if (Object.keys(updatePayload).length > 0) {
+            await client.patchWorkspace(`/maps/${mapId}`, updatePayload);
+        }
+        // Update privacy if provided (separate endpoint)
+        if (config.privacy) {
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)(`→ Updating privacy to ${config.privacy}...`));
+            }
+            const privacyPayload = { privacy: config.privacy };
+            if (config.sharingScope) {
+                privacyPayload.sharingScope = config.sharingScope;
+            }
+            await client.postWorkspace(`/maps/${mapId}/privacy`, privacyPayload);
+        }
+        // Get map URL
+        const mapUrl = `${client.workspaceUrl}/map/${mapId}`;
+        if (jsonOutput) {
+            console.log(JSON.stringify({
+                success: true,
+                mapId: mapId,
+                mapUrl: mapUrl,
+                updated: Object.keys(updatePayload).concat(config.privacy ? ['privacy'] : []),
+            }));
+        }
+        else {
+            console.log((0, colors_1.success)('✓ Map updated successfully!'));
+            console.log((0, colors_1.bold)('Map ID: ') + mapId);
+            console.log((0, colors_1.bold)('Map URL: ') + mapUrl);
+            const updatedFields = Object.keys(updatePayload).concat(config.privacy ? ['privacy'] : []);
+            if (updatedFields.length > 0) {
+                console.log((0, colors_1.dim)(`Updated: ${updatedFields.join(', ')}`));
+            }
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else if (err.message.includes('404')) {
+                console.log((0, colors_1.error)('✗ Map not found: ' + mapId));
+            }
+            else {
+                console.log((0, colors_1.error)('✗ Failed to update map: ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+}
+async function mapsClone(mapId, options, token, baseUrl, jsonOutput, debug = false, profile) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)(`Cloning map ${mapId}...`));
+        }
+        // Call the clone endpoint
+        const clonedMap = await client.postWorkspace(`/maps/${mapId}/clone`, {});
+        // Optionally rename the cloned map
+        if (options.title) {
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)(`→ Renaming cloned map to "${options.title}"...`));
+            }
+            await client.patchWorkspace(`/maps/${clonedMap.id}`, {
+                title: options.title,
+            });
+        }
+        // Get map URL
+        const mapUrl = `${client.workspaceUrl}/map/${clonedMap.id}`;
+        if (jsonOutput) {
+            console.log(JSON.stringify({
+                success: true,
+                sourceMapId: mapId,
+                clonedMapId: clonedMap.id,
+                mapUrl: mapUrl,
+            }));
+        }
+        else {
+            console.log((0, colors_1.success)('\n✓ Map cloned successfully!'));
+            console.log((0, colors_1.bold)('Source Map ID: ') + mapId);
+            console.log((0, colors_1.bold)('Cloned Map ID: ') + clonedMap.id);
+            console.log((0, colors_1.bold)('Map URL: ') + mapUrl);
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else if (err.message.includes('404')) {
+                console.log((0, colors_1.error)('✗ Map not found: ' + mapId));
+            }
+            else {
+                console.log((0, colors_1.error)('✗ Failed to clone map: ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+}