carto-cli 0.1.0-rc.1

package/dist/index.js

@@ -0,0 +1,1133 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const help_1 = require("./help");
+const workflows_1 = require("./commands/workflows");
+const auth_1 = require("./commands/auth");
+const credentials_1 = require("./commands/credentials");
+const maps_1 = require("./commands/maps");
+const connections_1 = require("./commands/connections");
+const imports_1 = require("./commands/imports");
+const admin_1 = require("./commands/admin");
+const org_1 = require("./commands/org");
+const activity_1 = require("./commands/activity");
+const sql_1 = require("./commands/sql");
+const users_1 = require("./commands/users");
+const ai_1 = require("./commands/ai");
+const colors_1 = require("./colors");
+const config_1 = require("./config");
+// Import package version
+const packageJson = require('../package.json');
+function parseArgs() {
+    const rawArgs = process.argv.slice(2);
+    const options = {
+        json: false,
+        debug: false,
+    };
+    const args = [];
+    let command = '';
+    let subcommand;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (arg === '--json') {
+            options.json = true;
+        }
+        else if (arg === '--debug') {
+            options.debug = true;
+        }
+        else if (arg === '--yes' || arg === '-y') {
+            options.yes = true;
+        }
+        else if (arg === '--token' && i + 1 < rawArgs.length) {
+            options.token = rawArgs[++i];
+        }
+        else if (arg === '--base-url' && i + 1 < rawArgs.length) {
+            options.baseUrl = rawArgs[++i];
+        }
+        else if (arg === '--profile' && i + 1 < rawArgs.length) {
+            options.profile = rawArgs[++i];
+        }
+        else if (arg === '--env' && i + 1 < rawArgs.length) {
+            options.env = rawArgs[++i];
+        }
+        else if (arg === '--organization-name' && i + 1 < rawArgs.length) {
+            options.organizationName = rawArgs[++i];
+        }
+        else if (arg === '--organization-id' && i + 1 < rawArgs.length) {
+            options.organizationId = rawArgs[++i];
+        }
+        else if (arg === '--m2m') {
+            options.m2m = true;
+        }
+        else if (arg === '--client-id' && i + 1 < rawArgs.length) {
+            options.clientId = rawArgs[++i];
+        }
+        else if (arg === '--client-secret' && i + 1 < rawArgs.length) {
+            options.clientSecret = rawArgs[++i];
+        }
+        else if (arg === '--api-base-url' && i + 1 < rawArgs.length) {
+            options.apiBaseUrl = rawArgs[++i];
+        }
+        else if (arg === '--force' || arg === '-f') {
+            options.force = true;
+        }
+        else if (arg === '--model' && i + 1 < rawArgs.length) {
+            options.model = rawArgs[++i];
+        }
+        else if (arg === '--system' && i + 1 < rawArgs.length) {
+            options.system = rawArgs[++i];
+        }
+        else if (arg === '--temperature' && i + 1 < rawArgs.length) {
+            options.temperature = rawArgs[++i];
+        }
+        else if (arg === '--max-tokens' && i + 1 < rawArgs.length) {
+            options.maxTokens = rawArgs[++i];
+        }
+        else if (arg === '--top-p' && i + 1 < rawArgs.length) {
+            options.topP = rawArgs[++i];
+        }
+        else if (arg === '--conversation-id' && i + 1 < rawArgs.length) {
+            options.conversationId = rawArgs[++i];
+        }
+        else if (arg === '--file' && i + 1 < rawArgs.length) {
+            options.file = rawArgs[++i];
+        }
+        else if (arg === '--help' || arg === '-h') {
+            (0, help_1.showHelp)();
+            process.exit(0);
+        }
+        else if (arg === '--version' || arg === '-v') {
+            console.log(`v${packageJson.version}`);
+            process.exit(0);
+        }
+        else if (!command) {
+            command = arg;
+        }
+        else if (!subcommand) {
+            subcommand = arg;
+        }
+        else {
+            args.push(arg);
+        }
+    }
+    return { command, subcommand, args, options };
+}
+async function main() {
+    const { command, subcommand, args, options } = parseArgs();
+    // Show help if no command
+    if (!command) {
+        (0, help_1.showHelp)();
+        return;
+    }
+    try {
+        // Auth commands
+        if (command === 'auth') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: auth command requires a subcommand (login, logout, status, use, whoami)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'login':
+                    const loginProfile = args.length > 0 ? args[0] : options.profile;
+                    const env = options.env || process.env.CARTO_AUTH_ENV;
+                    // Route to M2M login if --m2m flag is present
+                    if (options.m2m) {
+                        await (0, auth_1.authLoginM2M)(loginProfile, options.json, env, options.clientId, options.clientSecret, options.apiBaseUrl, options.force);
+                    }
+                    else {
+                        await (0, auth_1.authLogin)(loginProfile, options.json, env, options.organizationName, options.organizationId);
+                    }
+                    break;
+                case 'logout':
+                    const logoutProfile = args.length > 0 ? args[0] : options.profile;
+                    await (0, auth_1.authLogout)(logoutProfile, options.json);
+                    break;
+                case 'status':
+                    const statusProfile = args.length > 0 ? args[0] : options.profile;
+                    await (0, auth_1.authStatus)(statusProfile, options.json);
+                    break;
+                case 'use':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: auth use requires a profile name argument'));
+                        process.exit(1);
+                    }
+                    await (0, auth_1.authUse)(args[0], options.json);
+                    break;
+                case 'whoami':
+                    await (0, auth_1.authWhoami)(options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown auth subcommand: ${subcommand}`));
+                    console.log((0, colors_1.error)('For API token and OAuth client management, use: carto credentials'));
+                    process.exit(1);
+            }
+        }
+        // Maps commands
+        else if (command === 'maps') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: maps command requires a subcommand (list, get, create, update, delete, copy)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'list':
+                    const mapsOptions = {};
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i] === '--all') {
+                            mapsOptions.all = true;
+                        }
+                        else if (args[i] === '--mine') {
+                            mapsOptions.mine = true;
+                        }
+                        else if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '');
+                            const value = args[i + 1];
+                            mapsOptions[key] = value;
+                            i++; // Skip the value in next iteration
+                        }
+                    }
+                    await (0, maps_1.mapsList)(mapsOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'get':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: maps get requires a map ID argument'));
+                        process.exit(1);
+                    }
+                    await (0, maps_1.mapsGet)(args[0], options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'delete':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: maps delete requires a map ID argument'));
+                        process.exit(1);
+                    }
+                    await (0, maps_1.mapsDelete)(args[0], options.token, options.baseUrl, options.json, options.debug, options.profile, options.yes);
+                    break;
+                case 'copy':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: maps copy requires a map ID argument'));
+                        process.exit(1);
+                    }
+                    const mapId = args[0];
+                    const copyOptions = {};
+                    let connectionName;
+                    let sourceProfile;
+                    let destProfile;
+                    for (let i = 1; i < args.length; i++) {
+                        if (args[i] === '--connection' && i + 1 < args.length) {
+                            connectionName = args[++i];
+                        }
+                        else if (args[i] === '--connection-mapping' && i + 1 < args.length) {
+                            copyOptions.connectionMapping = args[++i];
+                        }
+                        else if (args[i] === '--source-profile' && i + 1 < args.length) {
+                            sourceProfile = args[++i];
+                        }
+                        else if (args[i] === '--dest-profile' && i + 1 < args.length) {
+                            destProfile = args[++i];
+                        }
+                        else if (args[i] === '--title' && i + 1 < args.length) {
+                            copyOptions.title = args[++i];
+                        }
+                        else if (args[i] === '--keep-privacy') {
+                            copyOptions.keepPrivacy = true;
+                        }
+                        else if (args[i] === '--skip-source-validation') {
+                            copyOptions.skipSourceValidation = true;
+                        }
+                        else if (args[i] === '--skip-agent') {
+                            copyOptions.skipAgent = true;
+                        }
+                    }
+                    if (!destProfile) {
+                        console.log((0, colors_1.error)('Error: maps copy requires --dest-profile <name>'));
+                        process.exit(1);
+                    }
+                    // Default source profile to current profile if not specified
+                    sourceProfile = sourceProfile || options.profile || (0, config_1.getCurrentProfile)();
+                    await (0, maps_1.mapsCopy)(mapId, connectionName, sourceProfile, destProfile, copyOptions, options.token, options.baseUrl, options.json, options.debug);
+                    break;
+                case 'create':
+                    // Parse --file flag
+                    const createOptions = {};
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i] === '--file' && i + 1 < args.length) {
+                            createOptions.file = args[++i];
+                        }
+                    }
+                    // First non-flag arg is the JSON string (if not using --file)
+                    const createJson = args.find(arg => !arg.startsWith('--') && arg !== createOptions.file);
+                    await (0, maps_1.mapsCreate)(createJson, createOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'update':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: maps update requires a map ID argument'));
+                        process.exit(1);
+                    }
+                    const updateMapId = args[0];
+                    const updateOptions = {};
+                    // Parse --file flag
+                    for (let i = 1; i < args.length; i++) {
+                        if (args[i] === '--file' && i + 1 < args.length) {
+                            updateOptions.file = args[++i];
+                        }
+                    }
+                    // Second arg (after map ID) is the JSON string (if not using --file)
+                    const updateJson = args.slice(1).find(arg => !arg.startsWith('--') && arg !== updateOptions.file);
+                    await (0, maps_1.mapsUpdate)(updateMapId, updateJson, updateOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'clone':
+                    const cloneOptions = {};
+                    const otherArgs = [];
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i] === '--title' && i + 1 < args.length) {
+                            cloneOptions.title = args[++i];
+                        }
+                        else {
+                            otherArgs.push(args[i]);
+                        }
+                    }
+                    const cloneMapId = otherArgs.find(arg => !arg.startsWith('--'));
+                    if (!cloneMapId) {
+                        console.log((0, colors_1.error)('Error: maps clone requires a map ID argument'));
+                        process.exit(1);
+                    }
+                    await (0, maps_1.mapsClone)(cloneMapId, cloneOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown maps subcommand: ${subcommand}`));
+                    process.exit(1);
+            }
+        }
+        // Workflows commands
+        else if (command === 'workflows') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: workflows command requires a subcommand (list, get, create, update, delete, copy, extensions, schedule)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'list':
+                    const workflowsOptions = {};
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i] === '--all') {
+                            workflowsOptions.all = true;
+                        }
+                        else if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '');
+                            const value = args[i + 1];
+                            workflowsOptions[key] = value;
+                            i++; // Skip the value in next iteration
+                        }
+                    }
+                    await (0, workflows_1.workflowsList)(workflowsOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'get':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: workflows get requires a workflow ID argument'));
+                        process.exit(1);
+                    }
+                    const getOptions = {};
+                    for (let i = 1; i < args.length; i += 2) {
+                        const key = args[i].replace(/^--/, '');
+                        const value = args[i + 1];
+                        getOptions[key] = value;
+                    }
+                    await (0, workflows_1.workflowsGet)(args[0], getOptions, options.token, options.baseUrl, options.json, options.debug);
+                    break;
+                case 'create':
+                    // Parse --file flag
+                    const createOptions = {};
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i] === '--file' && i + 1 < args.length) {
+                            createOptions.file = args[++i];
+                        }
+                    }
+                    // First non-flag arg is the JSON string (if not using --file)
+                    const createJson = args.find(arg => !arg.startsWith('--') && arg !== createOptions.file);
+                    await (0, workflows_1.workflowsCreate)(createJson, createOptions, options.token, options.baseUrl, options.json, options.debug);
+                    break;
+                case 'update':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: workflows update requires a workflow ID argument'));
+                        process.exit(1);
+                    }
+                    const updateWorkflowId = args[0];
+                    const updateOptions = {};
+                    // Parse --file flag
+                    for (let i = 1; i < args.length; i++) {
+                        if (args[i] === '--file' && i + 1 < args.length) {
+                            updateOptions.file = args[++i];
+                        }
+                    }
+                    // Second arg (after workflow ID) is the JSON string (if not using --file)
+                    const updateJson = args.slice(1).find(arg => !arg.startsWith('--') && arg !== updateOptions.file);
+                    await (0, workflows_1.workflowsUpdate)(updateWorkflowId, updateJson, updateOptions, options.token, options.baseUrl, options.json, options.debug);
+                    break;
+                case 'delete':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: workflows delete requires a workflow ID argument'));
+                        process.exit(1);
+                    }
+                    await (0, workflows_1.workflowsDelete)(args[0], options.token, options.baseUrl, options.json, options.debug, options.profile, options.yes);
+                    break;
+                case 'copy':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: workflows copy requires a workflow ID argument'));
+                        process.exit(1);
+                    }
+                    const workflowId = args[0];
+                    const copyOptions = {};
+                    let copyConnectionName;
+                    let copySourceProfile;
+                    let copyDestProfile;
+                    for (let i = 1; i < args.length; i++) {
+                        if (args[i] === '--connection' && i + 1 < args.length) {
+                            copyConnectionName = args[++i];
+                        }
+                        else if (args[i] === '--source-profile' && i + 1 < args.length) {
+                            copySourceProfile = args[++i];
+                        }
+                        else if (args[i] === '--dest-profile' && i + 1 < args.length) {
+                            copyDestProfile = args[++i];
+                        }
+                        else if (args[i] === '--title' && i + 1 < args.length) {
+                            copyOptions.title = args[++i];
+                        }
+                        else if (args[i] === '--skip-source-validation') {
+                            copyOptions.skipSourceValidation = true;
+                        }
+                    }
+                    if (!copyDestProfile) {
+                        console.log((0, colors_1.error)('Error: workflows copy requires --dest-profile <name>'));
+                        process.exit(1);
+                    }
+                    // Default source profile to current profile if not specified
+                    copySourceProfile = copySourceProfile || options.profile || (0, config_1.getCurrentProfile)();
+                    await (0, workflows_1.workflowsCopy)(workflowId, copyConnectionName, copySourceProfile, copyDestProfile, copyOptions, options.token, options.baseUrl, options.json, options.debug);
+                    break;
+                case 'extensions':
+                    // Handle extensions subcommands
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: workflows extensions requires a subcommand (install)'));
+                        process.exit(1);
+                    }
+                    const extensionSubcommand = args[0];
+                    if (extensionSubcommand === 'install') {
+                        let extensionFile;
+                        let connectionName;
+                        // Parse --file and --connection flags
+                        for (let i = 1; i < args.length; i++) {
+                            if (args[i] === '--file' && i + 1 < args.length) {
+                                extensionFile = args[++i];
+                            }
+                            else if (args[i] === '--connection' && i + 1 < args.length) {
+                                connectionName = args[++i];
+                            }
+                        }
+                        if (!extensionFile) {
+                            console.log((0, colors_1.error)('Error: workflows extensions install requires --file <path>'));
+                            process.exit(1);
+                        }
+                        if (!connectionName) {
+                            console.log((0, colors_1.error)('Error: workflows extensions install requires --connection <name>'));
+                            process.exit(1);
+                        }
+                        await (0, workflows_1.workflowsExtensionsInstall)(extensionFile, connectionName, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    else {
+                        console.log((0, colors_1.error)(`Error: unknown workflows extensions subcommand: ${extensionSubcommand}`));
+                        process.exit(1);
+                    }
+                    break;
+                case 'schedule':
+                    // Handle schedule subcommands
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: workflows schedule requires a subcommand (add, update, remove)'));
+                        process.exit(1);
+                    }
+                    const scheduleSubcommand = args[0];
+                    if (scheduleSubcommand === 'add') {
+                        if (args.length < 2) {
+                            console.log((0, colors_1.error)('Error: workflows schedule add requires workflow ID'));
+                            console.log('Usage: carto workflows schedule add <workflow-id> --expression "<expr>"');
+                            process.exit(1);
+                        }
+                        const workflowIdAdd = args[1];
+                        const addOptions = {};
+                        for (let i = 2; i < args.length; i++) {
+                            if (args[i] === '--expression' && i + 1 < args.length) {
+                                addOptions.expression = args[++i];
+                            }
+                        }
+                        await (0, workflows_1.workflowScheduleAdd)(workflowIdAdd, addOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    else if (scheduleSubcommand === 'update') {
+                        if (args.length < 2) {
+                            console.log((0, colors_1.error)('Error: workflows schedule update requires workflow ID'));
+                            console.log('Usage: carto workflows schedule update <workflow-id> --expression "<expr>"');
+                            process.exit(1);
+                        }
+                        const workflowIdUpdate = args[1];
+                        const updateScheduleOptions = {};
+                        for (let i = 2; i < args.length; i++) {
+                            if (args[i] === '--expression' && i + 1 < args.length) {
+                                updateScheduleOptions.expression = args[++i];
+                            }
+                        }
+                        await (0, workflows_1.workflowScheduleUpdate)(workflowIdUpdate, updateScheduleOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    else if (scheduleSubcommand === 'remove') {
+                        if (args.length < 2) {
+                            console.log((0, colors_1.error)('Error: workflows schedule remove requires workflow ID'));
+                            console.log('Usage: carto workflows schedule remove <workflow-id>');
+                            process.exit(1);
+                        }
+                        const workflowIdRemove = args[1];
+                        const removeOptions = {};
+                        await (0, workflows_1.workflowScheduleRemove)(workflowIdRemove, removeOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    else {
+                        console.log((0, colors_1.error)(`Error: unknown workflows schedule subcommand: ${scheduleSubcommand}`));
+                        process.exit(1);
+                    }
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown workflows subcommand: ${subcommand}`));
+                    process.exit(1);
+            }
+        }
+        // Connections commands
+        else if (command === 'connections') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: connections command requires a subcommand (list, get, create, update, delete, browse, describe)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'list':
+                    const connectionsOptions = {};
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i] === '--all') {
+                            connectionsOptions.all = true;
+                        }
+                        else if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '');
+                            const value = args[i + 1];
+                            connectionsOptions[key] = value;
+                            i++; // Skip the value in next iteration
+                        }
+                    }
+                    await (0, connections_1.connectionsList)(connectionsOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'get':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: connections get requires a connection ID argument'));
+                        process.exit(1);
+                    }
+                    await (0, connections_1.connectionsGet)(args[0], options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'browse':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: connections browse requires a connection name argument'));
+                        process.exit(1);
+                    }
+                    const connectionName = args[0];
+                    const resourcePath = args.length > 1 ? args[1] : undefined;
+                    const browseOptions = {};
+                    // Parse pagination options
+                    for (let i = 2; i < args.length; i++) {
+                        if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '');
+                            const value = args[i + 1];
+                            browseOptions[key] = value;
+                            i++; // Skip the value in next iteration
+                        }
+                    }
+                    await (0, connections_1.connectionsBrowse)(connectionName, resourcePath, browseOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'describe':
+                    if (args.length < 2) {
+                        console.log((0, colors_1.error)('Error: connections describe requires connection name and table path'));
+                        console.log('Usage: carto connections describe <connection-name> <table-path>');
+                        console.log('Example: carto connections describe carto_dw "carto-demo-data.demo_tables.nyc_collisions"');
+                        process.exit(1);
+                    }
+                    await (0, connections_1.connectionsDescribe)(args[0], // connection name
+                    args[1], // table path
+                    options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'create':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: connections create requires JSON body as argument'));
+                        process.exit(1);
+                    }
+                    const createConnBody = JSON.parse(args[0]);
+                    await (0, connections_1.connectionsCreate)(createConnBody, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'update':
+                    if (args.length < 2) {
+                        console.log((0, colors_1.error)('Error: connections update requires connection ID and JSON body as arguments'));
+                        process.exit(1);
+                    }
+                    const updateConnBody = JSON.parse(args[1]);
+                    await (0, connections_1.connectionsUpdate)(args[0], updateConnBody, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'delete':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: connections delete requires a connection ID argument'));
+                        process.exit(1);
+                    }
+                    await (0, connections_1.connectionsDelete)(args[0], options.token, options.baseUrl, options.json, options.debug, options.profile, options.yes);
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown connections subcommand: ${subcommand}`));
+                    process.exit(1);
+            }
+        }
+        // Imports commands
+        else if (command === 'imports') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: imports command requires a subcommand (create)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'create':
+                    const importsOptions = {};
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i] === '--async') {
+                            importsOptions.async = true;
+                        }
+                        else if (args[i] === '--overwrite') {
+                            importsOptions.overwrite = true;
+                        }
+                        else if (args[i] === '--no-autoguessing') {
+                            importsOptions.noAutoguessing = true;
+                        }
+                        else if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '');
+                            if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+                                const value = args[i + 1];
+                                importsOptions[key] = value;
+                                i++; // Skip the value in next iteration
+                            }
+                        }
+                    }
+                    await (0, imports_1.importsCreate)(importsOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown imports subcommand: ${subcommand}`));
+                    process.exit(1);
+            }
+        }
+        // Admin commands
+        else if (command === 'admin') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: admin command requires a subcommand (list, batch-delete, transfer)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'list':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: admin list requires a resource type argument (maps, workflows, connections)'));
+                        process.exit(1);
+                    }
+                    const adminOptions = {};
+                    for (let i = 1; i < args.length; i++) {
+                        if (args[i] === '--all') {
+                            adminOptions.all = true;
+                        }
+                        else if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '');
+                            const value = args[i + 1];
+                            adminOptions[key] = value;
+                            i++; // Skip the value in next iteration
+                        }
+                    }
+                    await (0, admin_1.adminList)(args[0], adminOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'batch-delete':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: admin batch-delete requires JSON body as argument'));
+                        process.exit(1);
+                    }
+                    const batchDeleteBody = JSON.parse(args[0]);
+                    await (0, admin_1.adminBatchDelete)(batchDeleteBody, options.token, options.baseUrl, options.json, options.debug, options.profile, options.yes);
+                    break;
+                case 'transfer':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: admin transfer requires JSON body as argument'));
+                        process.exit(1);
+                    }
+                    const transferBody = JSON.parse(args[0]);
+                    await (0, admin_1.adminTransfer)(transferBody, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown admin subcommand: ${subcommand}`));
+                    process.exit(1);
+            }
+        }
+        // Organization commands
+        else if (command === 'org') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: org command requires a subcommand (stats)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'stats':
+                    await (0, org_1.orgStats)(options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown org subcommand: ${subcommand}`));
+                    process.exit(1);
+            }
+        }
+        // SQL commands
+        else if (command === 'sql') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: sql command requires a subcommand (query, job)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'query':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: sql query requires a connection name argument'));
+                        process.exit(1);
+                    }
+                    const queryConnection = args[0];
+                    let querySql;
+                    const queryOptions = {};
+                    // Parse options and SQL
+                    for (let i = 1; i < args.length; i++) {
+                        if (args[i] === '--cache') {
+                            queryOptions.cache = true;
+                        }
+                        else if (args[i] === '--file' && i + 1 < args.length) {
+                            queryOptions.file = args[++i];
+                        }
+                        else if (!querySql && !args[i].startsWith('--')) {
+                            // First non-flag argument after connection is the SQL
+                            querySql = args[i];
+                        }
+                    }
+                    await (0, sql_1.sqlQuery)(queryConnection, querySql, queryOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'job':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: sql job requires a connection name or subcommand (status, cancel)'));
+                        process.exit(1);
+                    }
+                    // Check if first arg is a subcommand (status, cancel)
+                    if (args[0] === 'status') {
+                        if (args.length < 3) {
+                            console.log((0, colors_1.error)('Error: sql job status requires connection name and job ID'));
+                            process.exit(1);
+                        }
+                        const { sqlJobStatus } = await Promise.resolve().then(() => __importStar(require('./commands/sql')));
+                        await sqlJobStatus(args[1], // connection
+                        args[2], // job ID
+                        options.token, options.baseUrl, options.json, options.debug, options.profile);
+                        break;
+                    }
+                    if (args[0] === 'cancel') {
+                        if (args.length < 3) {
+                            console.log((0, colors_1.error)('Error: sql job cancel requires connection name and job ID'));
+                            process.exit(1);
+                        }
+                        const { sqlJobCancel } = await Promise.resolve().then(() => __importStar(require('./commands/sql')));
+                        await sqlJobCancel(args[1], // connection
+                        args[2], // job ID
+                        options.token, options.baseUrl, options.json, options.debug, options.profile);
+                        break;
+                    }
+                    // Otherwise, it's a job creation command
+                    const jobConnection = args[0];
+                    let jobSql;
+                    const jobOptions = {};
+                    // Parse options and SQL
+                    for (let i = 1; i < args.length; i++) {
+                        if (args[i] === '--file' && i + 1 < args.length) {
+                            jobOptions.file = args[++i];
+                        }
+                        else if (args[i] === '--no-wait') {
+                            jobOptions.noWait = true;
+                        }
+                        else if (!jobSql && !args[i].startsWith('--')) {
+                            // First non-flag argument after connection is the SQL
+                            jobSql = args[i];
+                        }
+                    }
+                    await (0, sql_1.sqlJob)(jobConnection, jobSql, jobOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown sql subcommand: ${subcommand}`));
+                    process.exit(1);
+            }
+        }
+        // Activity commands
+        else if (command === 'activity') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: activity command requires a subcommand (export, query)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'export':
+                    const activityOptions = {
+                        outputDir: './activity-data'
+                    };
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '');
+                            const value = args[i + 1];
+                            if (key === 'start-date') {
+                                activityOptions.startDate = value;
+                                i++;
+                            }
+                            else if (key === 'end-date') {
+                                activityOptions.endDate = value;
+                                i++;
+                            }
+                            else if (key === 'format') {
+                                activityOptions.format = value;
+                                i++;
+                            }
+                            else if (key === 'category') {
+                                activityOptions.category = value;
+                                i++;
+                            }
+                            else if (key === 'output-dir') {
+                                activityOptions.outputDir = value;
+                                i++;
+                            }
+                        }
+                    }
+                    await (0, activity_1.activityExport)(activityOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'query':
+                    const activityQueryOptions = {
+                        noCache: false
+                    };
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i] === '--no-cache') {
+                            activityQueryOptions.noCache = true;
+                        }
+                        else if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '');
+                            const value = args[i + 1];
+                            if (key === 'start-date') {
+                                activityQueryOptions.startDate = value;
+                                i++;
+                            }
+                            else if (key === 'end-date') {
+                                activityQueryOptions.endDate = value;
+                                i++;
+                            }
+                            else if (key === 'sql') {
+                                activityQueryOptions.sql = value;
+                                i++;
+                            }
+                        }
+                    }
+                    await (0, activity_1.activityQuery)(activityQueryOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown activity subcommand: ${subcommand}`));
+                    process.exit(1);
+            }
+        }
+        // Users commands
+        else if (command === 'users') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: users command requires a subcommand (list, get, invite, invitations, resend-invitation, cancel-invitation, delete)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'list':
+                    const usersOptions = {};
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i] === '--all') {
+                            usersOptions.all = true;
+                        }
+                        else if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '');
+                            const value = args[i + 1];
+                            usersOptions[key] = value;
+                            i++; // Skip the value in next iteration
+                        }
+                    }
+                    await (0, users_1.usersList)(usersOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'get':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: users get requires a user ID argument'));
+                        process.exit(1);
+                    }
+                    await (0, users_1.usersGet)(args[0], options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'invite':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: users invite requires at least one email address'));
+                        process.exit(1);
+                    }
+                    // Parse emails and role
+                    let emails = [];
+                    let role = 'Viewer'; // default role
+                    for (let i = 0; i < args.length; i++) {
+                        if (args[i] === '--role' && i + 1 < args.length) {
+                            role = args[++i];
+                        }
+                        else if (!args[i].startsWith('--')) {
+                            // Split by comma in case multiple emails are provided
+                            emails = emails.concat(args[i].split(',').map(e => e.trim()));
+                        }
+                    }
+                    if (emails.length === 0) {
+                        console.log((0, colors_1.error)('Error: users invite requires at least one email address'));
+                        process.exit(1);
+                    }
+                    await (0, users_1.usersInvite)(emails, role, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'invitations':
+                    await (0, users_1.usersInvitations)(options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'resend-invitation':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: users resend-invitation requires an invitation token argument'));
+                        process.exit(1);
+                    }
+                    await (0, users_1.usersResendInvitation)(args[0], options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'cancel-invitation':
+                    if (args.length === 0) {
+                        console.log((0, colors_1.error)('Error: users cancel-invitation requires an invitation token argument'));
+                        process.exit(1);
+                    }
+                    await (0, users_1.usersCancelInvitation)(args[0], options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'delete':
+                    if (args.length < 2) {
+                        console.log((0, colors_1.error)('Error: users delete requires user identifier and receiver user identifier'));
+                        console.log('Usage: carto users delete <user-id|email> <receiver-user-id|email>');
+                        console.log('Both arguments accept user IDs or email addresses.');
+                        console.log('The receiver user is who will receive the deleted user\'s resources.');
+                        process.exit(1);
+                    }
+                    await (0, users_1.usersDelete)(args[0], args[1], options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown users subcommand: ${subcommand}`));
+                    process.exit(1);
+            }
+        }
+        // AI Feature commands
+        else if (command === 'aifeature') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: aifeature command requires a feature name (aiagent, workflowsCreatorAgent, etc.)'));
+                console.log('Usage: carto aifeature aiagent <map-id> [message]');
+                process.exit(1);
+            }
+            // AI Feature commands: carto aifeature aiagent, carto aifeature workflowsCreatorAgent, etc.
+            await (0, ai_1.handleAiFeature)(subcommand, args, options, options.token, options.baseUrl, options.json, options.debug, options.profile);
+        }
+        // AI Proxy commands
+        else if (command === 'aiproxy') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: aiproxy command requires a subcommand (chat, models, info)'));
+                console.log('Usage: carto aiproxy chat [message]');
+                console.log('       carto aiproxy models');
+                console.log('       carto aiproxy info');
+                process.exit(1);
+            }
+            // AI Proxy commands: carto aiproxy chat, carto aiproxy models
+            // Pass subcommand as first element of args array
+            await (0, ai_1.handleAiProxy)([subcommand, ...args], options, options.token, options.baseUrl, options.json, options.debug, options.profile);
+        }
+        // Credentials commands
+        else if (command === 'credentials') {
+            if (!subcommand) {
+                console.log((0, colors_1.error)('Error: credentials command requires a subcommand (list, create, get, update, delete)'));
+                process.exit(1);
+            }
+            switch (subcommand) {
+                case 'list':
+                    const listType = args[0]; // undefined, 'tokens', 'spa', 'm2m', 'oauth'
+                    const credListOptions = {};
+                    for (let i = 1; i < args.length; i++) {
+                        if (args[i] === '--all') {
+                            credListOptions.all = true;
+                        }
+                        else if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '');
+                            const value = args[i + 1];
+                            credListOptions[key] = value;
+                            i++; // Skip the value in next iteration
+                        }
+                    }
+                    await (0, credentials_1.credentialsList)(listType, credListOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    break;
+                case 'create':
+                    const createType = args[0]; // 'token', 'spa', 'm2m'
+                    if (!createType || !['token', 'spa', 'm2m'].includes(createType)) {
+                        console.log((0, colors_1.error)('Error: credentials create requires type (token, spa, m2m)'));
+                        process.exit(1);
+                    }
+                    // Parse flags and options
+                    const createOptions = {};
+                    for (let i = 1; i < args.length; i++) {
+                        if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '').replace(/-/g, '_');
+                            // Check for flags without values
+                            if (i + 1 >= args.length || args[i + 1].startsWith('--')) {
+                                createOptions[key] = true;
+                            }
+                            else {
+                                let value = args[i + 1];
+                                // Handle special keys that might have multiple values
+                                if (key === 'connection' || key === 'source') {
+                                    if (!createOptions[key]) {
+                                        createOptions[key] = [];
+                                    }
+                                    if (!Array.isArray(createOptions[key])) {
+                                        createOptions[key] = [createOptions[key]];
+                                    }
+                                    createOptions[key].push(value);
+                                }
+                                else {
+                                    createOptions[key] = value;
+                                }
+                                i++; // Skip the value in next iteration
+                            }
+                        }
+                    }
+                    if (createType === 'token') {
+                        await (0, credentials_1.credentialsCreateToken)(createOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    else if (createType === 'spa') {
+                        await (0, credentials_1.credentialsCreateSPA)(createOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    else if (createType === 'm2m') {
+                        await (0, credentials_1.credentialsCreateM2M)(createOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    break;
+                case 'get':
+                    const getType = args[0]; // 'token', 'spa', 'm2m', 'oauth'
+                    const getId = args[1];
+                    if (!getType || !['token', 'spa', 'm2m', 'oauth'].includes(getType)) {
+                        console.log((0, colors_1.error)('Error: credentials get requires type (token, spa, m2m, oauth)'));
+                        process.exit(1);
+                    }
+                    if (!getId) {
+                        console.log((0, colors_1.error)(`Error: credentials get ${getType} requires an ID argument`));
+                        process.exit(1);
+                    }
+                    if (getType === 'token') {
+                        await (0, credentials_1.credentialsGetToken)(getId, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    else {
+                        await (0, credentials_1.credentialsGetOAuth)(getId, getType, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    break;
+                case 'update':
+                    const updateType = args[0]; // 'token', 'spa', 'm2m', 'oauth'
+                    const updateId = args[1];
+                    if (!updateType || !['token', 'spa', 'm2m', 'oauth'].includes(updateType)) {
+                        console.log((0, colors_1.error)('Error: credentials update requires type (token, spa, m2m, oauth)'));
+                        process.exit(1);
+                    }
+                    if (!updateId) {
+                        console.log((0, colors_1.error)(`Error: credentials update ${updateType} requires an ID argument`));
+                        process.exit(1);
+                    }
+                    // Parse flags and options
+                    const updateOptions = {};
+                    for (let i = 2; i < args.length; i++) {
+                        if (args[i].startsWith('--')) {
+                            const key = args[i].replace(/^--/, '').replace(/-/g, '_');
+                            // Check for flags without values
+                            if (i + 1 >= args.length || args[i + 1].startsWith('--')) {
+                                updateOptions[key] = true;
+                            }
+                            else {
+                                updateOptions[key] = args[i + 1];
+                                i++; // Skip the value in next iteration
+                            }
+                        }
+                    }
+                    if (updateType === 'token') {
+                        await (0, credentials_1.credentialsUpdateToken)(updateId, updateOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    else {
+                        await (0, credentials_1.credentialsUpdateOAuth)(updateId, updateOptions, options.token, options.baseUrl, options.json, options.debug, options.profile);
+                    }
+                    break;
+                case 'delete':
+                case 'revoke':
+                    const deleteType = args[0]; // 'token', 'spa', 'm2m', 'oauth'
+                    const deleteId = args[1];
+                    if (!deleteType || !['token', 'spa', 'm2m', 'oauth'].includes(deleteType)) {
+                        console.log((0, colors_1.error)('Error: credentials delete requires type (token, spa, m2m, oauth)'));
+                        process.exit(1);
+                    }
+                    if (!deleteId) {
+                        console.log((0, colors_1.error)(`Error: credentials delete ${deleteType} requires an ID argument`));
+                        process.exit(1);
+                    }
+                    if (deleteType === 'token') {
+                        await (0, credentials_1.credentialsDeleteToken)(deleteId, options.token, options.baseUrl, options.json, options.debug, options.profile, options.yes);
+                    }
+                    else {
+                        await (0, credentials_1.credentialsDeleteOAuth)(deleteId, options.token, options.baseUrl, options.json, options.debug, options.profile, options.yes);
+                    }
+                    break;
+                default:
+                    console.log((0, colors_1.error)(`Error: unknown credentials subcommand: ${subcommand}`));
+                    process.exit(1);
+            }
+        }
+        // Unknown command
+        else {
+            console.log((0, colors_1.error)(`Error: unknown command: ${command}`));
+            console.log('Run "carto --help" for usage information');
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            console.log((0, colors_1.error)('Error: ' + err.message));
+        }
+        process.exit(1);
+    }
+}
+main();