@claryai/cli 0.1.0

package/dist/handlers/deploy.js

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployHandler = exports.deploy = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const url_1 = require("url");
+const uuid_1 = require("uuid");
+const analytics_1 = require("../analytics/analytics");
+const config_1 = require("../config");
+const context_1 = require("../dbt/context");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const lightdash_config_1 = require("../lightdash-config");
+const projectType_1 = require("../lightdash/projectType");
+const styles = tslib_1.__importStar(require("../styles"));
+const compile_1 = require("./compile");
+const createProject_1 = require("./createProject");
+const apiClient_1 = require("./dbt/apiClient");
+const getDbtVersion_1 = require("./dbt/getDbtVersion");
+const selectProject_1 = require("./selectProject");
+const replaceProjectYamlTags = async (projectUuid, lightdashProjectConfig) => {
+    const yamlTags = Object.entries(lightdashProjectConfig.spotlight?.categories ?? {}).map(([yamlReference, category]) => ({
+        yamlReference,
+        name: category.label,
+        color: category.color ?? 'gray',
+    }));
+    await (0, apiClient_1.lightdashApi)({
+        method: 'PUT',
+        url: `/api/v1/projects/${projectUuid}/tags/yaml`,
+        body: JSON.stringify(yamlTags),
+    });
+};
+const replaceProjectParameters = async (projectUuid, lightdashProjectConfig) => {
+    await (0, apiClient_1.lightdashApi)({
+        method: 'PUT',
+        url: `/api/v2/projects/${projectUuid}/parameters`,
+        body: JSON.stringify(lightdashProjectConfig.parameters ?? {}),
+    });
+};
+const replaceProjectDefaults = async (projectUuid, lightdashProjectConfig) => {
+    if (lightdashProjectConfig.defaults) {
+        await (0, apiClient_1.lightdashApi)({
+            method: 'PUT',
+            url: `/api/v2/projects/${projectUuid}/defaults`,
+            body: JSON.stringify(lightdashProjectConfig.defaults),
+        });
+    }
+};
+const deployBatched = async (explores, options) => {
+    const batchSize = parseInt(options.batchSize || '50', 10);
+    if (Number.isNaN(batchSize) || batchSize < 1 || batchSize > 1000) {
+        throw new Error('batchSize must be a positive integer between 1 and 1000');
+    }
+    const parallelBatches = parseInt(options.parallelBatches || '1', 10);
+    if (Number.isNaN(parallelBatches) ||
+        parallelBatches < 1 ||
+        parallelBatches > 50) {
+        throw new Error('parallelBatches must be a positive integer between 1 and 50');
+    }
+    globalState_1.default.log(styles.title(`Deploying ${explores.length} explores using batched deploy (batch size: ${batchSize}, parallel: ${parallelBatches})`));
+    const deployStartTime = Date.now();
+    // Start deploy session
+    globalState_1.default.log(`Starting deploy session...`);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const startSessionResponse = (await (0, apiClient_1.lightdashApi)({
+        method: 'POST',
+        url: `/api/v2/projects/${options.projectUuid}/deploy`,
+        body: JSON.stringify({}),
+    }));
+    const sessionUuid = startSessionResponse.deploySessionUuid;
+    globalState_1.default.log(styles.success(`Deploy session created: ${sessionUuid}`));
+    // Split explores into batches
+    const batches = [];
+    for (let i = 0; i < explores.length; i += batchSize) {
+        batches.push(explores.slice(i, i + batchSize));
+    }
+    globalState_1.default.log(`Uploading ${batches.length} batches...`);
+    // Send batches with parallelism using chunked processing
+    const uploadBatch = async (batch, batchIndex) => {
+        globalState_1.default.log(`  Uploading batch ${batchIndex + 1}/${batches.length} (${batch.length} explores)...`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const response = (await (0, apiClient_1.lightdashApi)({
+            method: 'POST',
+            url: `/api/v2/projects/${options.projectUuid}/deploy/${sessionUuid}/batch`,
+            body: JSON.stringify({
+                explores: batch,
+                batchNumber: batchIndex,
+            }),
+        }));
+        globalState_1.default.log(styles.success(`  ✓ Batch ${batchIndex + 1} uploaded (${response.exploreCount} explores)`));
+        return response;
+    };
+    // Process batches with controlled parallelism using recursive approach
+    const processBatchesWithParallelism = async (remainingIndices, results = []) => {
+        if (remainingIndices.length === 0) {
+            return results;
+        }
+        const chunk = remainingIndices.slice(0, parallelBatches);
+        const remaining = remainingIndices.slice(parallelBatches);
+        const chunkPromises = chunk.map((index) => uploadBatch(batches[index], index));
+        const chunkResults = await Promise.all(chunkPromises);
+        return processBatchesWithParallelism(remaining, [
+            ...results,
+            ...chunkResults,
+        ]);
+    };
+    const batchIndices = Array.from({ length: batches.length }, (_, i) => i);
+    await processBatchesWithParallelism(batchIndices);
+    // Finalize deploy
+    globalState_1.default.log(`Finalizing deploy...`);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const finalizeResponse = (await (0, apiClient_1.lightdashApi)({
+        method: 'POST',
+        url: `/api/v2/projects/${options.projectUuid}/deploy/${sessionUuid}/finalize`,
+        body: JSON.stringify({}),
+    }));
+    globalState_1.default.log(styles.success(`Deploy completed! ${finalizeResponse.exploreCount} explores deployed.`));
+    await analytics_1.LightdashAnalytics.track({
+        event: 'deploy.triggered',
+        properties: {
+            projectId: options.projectUuid,
+            durationMs: Date.now() - deployStartTime,
+        },
+    });
+};
+const deploy = async (explores, options) => {
+    if (explores.length === 0) {
+        globalState_1.default.log(styles.warning('No explores found'));
+        process.exit(1);
+    }
+    const errors = explores.filter((e) => (0, common_1.isExploreError)(e)).length;
+    if (errors > 0) {
+        if (options.ignoreErrors) {
+            console.error(styles.warning(`\nDeploying project with ${errors} errors\n`));
+        }
+        else {
+            console.error(styles.error(`Can't deploy with errors. If you still want to deploy, add ${styles.bold('--ignore-errors')} flag`));
+            process.exit(1);
+        }
+    }
+    const lightdashProjectConfig = await (0, lightdash_config_1.readAndLoadLightdashProjectConfig)(path_1.default.resolve(options.projectDir), options.projectUuid);
+    // These two methods are not critical to the deployment process, so we can ignore errors and show warnings instead
+    try {
+        await replaceProjectYamlTags(options.projectUuid, lightdashProjectConfig);
+    }
+    catch (e) {
+        console.error(styles.warning(`\nError replacing YAML tags: ${(0, common_1.getErrorMessage)(e)}\n`));
+    }
+    try {
+        await replaceProjectParameters(options.projectUuid, lightdashProjectConfig);
+    }
+    catch (e) {
+        console.error(styles.warning(`\nError replacing project parameters: ${(0, common_1.getErrorMessage)(e)}\n`));
+    }
+    try {
+        await replaceProjectDefaults(options.projectUuid, lightdashProjectConfig);
+    }
+    catch (e) {
+        console.error(styles.warning(`\nError replacing project defaults: ${(0, common_1.getErrorMessage)(e)}\n`));
+    }
+    // Use batched deploy if enabled
+    if (options.useBatchedDeploy) {
+        await deployBatched(explores, options);
+    }
+    else {
+        const deployStartTime = Date.now();
+        const deployPayload = JSON.stringify(explores);
+        try {
+            await (0, apiClient_1.lightdashApi)({
+                method: 'PUT',
+                url: `/api/v1/projects/${options.projectUuid}/explores`,
+                body: deployPayload,
+            });
+            await analytics_1.LightdashAnalytics.track({
+                event: 'deploy.triggered',
+                properties: {
+                    projectId: options.projectUuid,
+                    durationMs: Date.now() - deployStartTime,
+                    payloadSizeBytes: Buffer.byteLength(deployPayload),
+                },
+            });
+        }
+        catch (error) {
+            // Check if it's a payload too large error (413) or similar size-related errors
+            const errorStatus = error.status;
+            const errorMessage = error.message;
+            if (errorStatus === 413 ||
+                errorMessage?.includes('too large') ||
+                errorMessage?.includes('payload') ||
+                errorMessage?.includes('Request Entity Too Large') ||
+                errorMessage?.includes('413')) {
+                console.error(styles.error('\n❌ Deploy failed: Payload too large\n'));
+                console.error(styles.warning('Your project is too large to deploy in a single request.\n' +
+                    'Please use the batched deploy feature:\n\n' +
+                    `  ${styles.bold('clary deploy --use-batched-deploy')}\n\n` +
+                    'You can also customize batch size and parallelism:\n' +
+                    `  ${styles.bold('--batch-size <number>')}      Number of explores per batch (default: 50)\n` +
+                    `  ${styles.bold('--parallel-batches <number>')} Number of parallel batches (default: 1)\n`));
+                process.exit(1);
+            }
+            // Re-throw other errors to be handled by the caller
+            throw error;
+        }
+    }
+};
+exports.deploy = deploy;
+const createNewProject = async (executionId, options) => {
+    console.error('');
+    const absoluteProjectPath = path_1.default.resolve(options.projectDir);
+    let defaultProjectName = 'My new Clary Project'; // TODO: improve
+    try {
+        const context = await (0, context_1.getDbtContext)({
+            projectDir: absoluteProjectPath,
+            targetPath: options.targetPath,
+        });
+        defaultProjectName = (0, common_1.friendlyName)(context.projectName);
+    }
+    catch (e) {
+        if (e instanceof common_1.ParseError) {
+            // stick with default name
+        }
+    }
+    // If interactive and no name provided, prompt for project name
+    let projectName = defaultProjectName;
+    if (options.create === true && !globalState_1.default.isNonInteractive()) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: `Add a project name or press enter to use the default: [${defaultProjectName}] `,
+            },
+        ]);
+        projectName = answers.name ? answers.name : defaultProjectName;
+    }
+    // If explicit name provided, use it
+    if (typeof options.create === 'string') {
+        projectName = options.create;
+    }
+    projectName = projectName.trim();
+    // Create the project
+    console.error('');
+    const spinner = globalState_1.default.startSpinner(`  Creating new project ${styles.bold(projectName)}`);
+    const createStartTime = Date.now();
+    await analytics_1.LightdashAnalytics.track({
+        event: 'create.started',
+        properties: {
+            executionId,
+            projectName,
+            isDefaultName: defaultProjectName === projectName,
+        },
+    });
+    try {
+        const results = await (0, createProject_1.createProject)({
+            ...options,
+            name: projectName,
+            type: common_1.ProjectType.DEFAULT,
+            warehouseCredentials: options.warehouseCredentials,
+            assumeYes: options.assumeYes,
+        });
+        const project = results?.project;
+        if (!project) {
+            spinner.fail('Cancel preview environment');
+            return undefined;
+        }
+        spinner.succeed(`  New project ${styles.bold(projectName)} created\n`);
+        await analytics_1.LightdashAnalytics.track({
+            event: 'create.completed',
+            properties: {
+                executionId,
+                projectId: project.projectUuid,
+                projectName,
+                durationMs: Date.now() - createStartTime,
+            },
+        });
+        return project;
+    }
+    catch (e) {
+        await analytics_1.LightdashAnalytics.track({
+            event: 'create.error',
+            properties: {
+                executionId,
+                error: `Error creating developer preview ${e}`,
+            },
+        });
+        spinner.fail();
+        throw e;
+    }
+};
+const deployHandler = async (originalOptions) => {
+    const options = {
+        ...originalOptions,
+    };
+    globalState_1.default.setVerbose(options.verbose);
+    // Detect project type and configure options accordingly
+    const projectTypeConfig = await (0, projectType_1.detectProjectType)({
+        projectDir: options.projectDir,
+        userOptions: {
+            warehouseCredentials: options.warehouseCredentials,
+            skipDbtCompile: options.skipDbtCompile,
+            skipWarehouseCatalog: options.skipWarehouseCatalog,
+        },
+    });
+    // Apply project type configuration to options
+    options.warehouseCredentials = projectTypeConfig.warehouseCredentials;
+    options.skipDbtCompile = projectTypeConfig.skipDbtCompile;
+    options.skipWarehouseCatalog = projectTypeConfig.skipWarehouseCatalog;
+    // Resolve organization credentials early before doing any heavy work
+    if (options.organizationCredentials) {
+        try {
+            await (0, createProject_1.resolveOrganizationCredentialsName)(options.organizationCredentials);
+        }
+        catch (error) {
+            console.error(styles.error(error instanceof Error ? error.message : 'Unknown error'));
+            process.exit(1);
+        }
+    }
+    // Only check dbt version for dbt projects (YAML-only projects don't need dbt)
+    // For YAML-only projects, we return success: false to indicate dbt wasn't checked,
+    // with null error since this is expected behavior, not an error condition.
+    // This allows downstream code to distinguish "dbt check skipped" from "dbt check failed".
+    const dbtVersionResult = projectTypeConfig.type === projectType_1.CliProjectType.Dbt
+        ? await (0, getDbtVersion_1.tryGetDbtVersion)()
+        : { success: false, error: null };
+    if (options.gzip) {
+        (0, apiClient_1.setGzipEnabled)(true);
+    }
+    await (0, apiClient_1.checkLightdashVersion)();
+    const executionId = (0, uuid_1.v4)();
+    const explores = await (0, compile_1.compile)(options);
+    const config = await (0, config_1.getConfig)();
+    let projectUuid;
+    if (options.create !== undefined) {
+        const project = await createNewProject(executionId, options);
+        if (!project) {
+            console.error("To preview your project, you'll need to manually enter your warehouse connection details.");
+            const createProjectUrl = config.context?.serverUrl &&
+                new url_1.URL('/createProject', config.context.serverUrl);
+            if (createProjectUrl) {
+                console.error(`Fill out the project connection form here: ${createProjectUrl}`);
+            }
+            return;
+        }
+        projectUuid = project.projectUuid;
+        await (0, config_1.setProject)(projectUuid, project.name);
+    }
+    else {
+        if (!config.context?.serverUrl) {
+            throw new common_1.AuthorizationError(`No active Clary project. Run 'clary login --help'`);
+        }
+        const projectSelection = await (0, selectProject_1.selectProject)(config);
+        if (!projectSelection) {
+            throw new common_1.AuthorizationError(`No active Clary project. Run 'clary login --help'`);
+        }
+        projectUuid = projectSelection.projectUuid;
+        // Log current project info
+        (0, selectProject_1.logSelectedProject)(projectSelection, config, 'Deploying to');
+    }
+    await (0, exports.deploy)(explores, { ...options, projectUuid });
+    const serverUrl = config.context?.serverUrl?.replace(/\/$/, '');
+    let displayUrl = options.create
+        ? `${serverUrl}/createProject/cli?projectUuid=${projectUuid}`
+        : `${serverUrl}/projects/${projectUuid}/home`;
+    let successMessage = 'Successfully deployed project:';
+    if (dbtVersionResult.success &&
+        dbtVersionResult.version.isDbtCloudCLI &&
+        options.create) {
+        successMessage =
+            'Successfully deployed project! Complete the setup by adding warehouse connection details here:';
+        displayUrl = `${serverUrl}/generalSettings/projectManagement/${projectUuid}/settings`;
+    }
+    console.error(`${styles.bold(successMessage)}`);
+    console.error('');
+    console.error(`      ${styles.bold(`⚡️ ${displayUrl}`)}`);
+    console.error('');
+};
+exports.deployHandler = deployHandler;

package/dist/handlers/diagnostics.d.ts

@@ -0,0 +1,11 @@
+type DiagnosticsOptions = {
+    dbt?: boolean;
+    projectDir?: string;
+    profilesDir?: string;
+    defer?: boolean;
+    noDefer?: boolean;
+    state?: string;
+};
+export declare const diagnosticsHandler: (options: DiagnosticsOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/handlers/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../src/handlers/diagnostics.ts"],"names":[],"mappings":"AAgBA,KAAK,kBAAkB,GAAG;IACtB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAwGF,eAAO,MAAM,kBAAkB,GAAU,SAAS,kBAAkB,kBAkInE,CAAC"}

package/dist/handlers/diagnostics.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnosticsHandler = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const execa_1 = tslib_1.__importDefault(require("execa"));
+const analytics_1 = require("../analytics/analytics");
+const config_1 = require("../config");
+const env_1 = require("../env");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+const apiClient_1 = require("./dbt/apiClient");
+const getDbtVersion_1 = require("./dbt/getDbtVersion");
+const getEnvSourceSuffix = (names, env = process.env) => {
+    const activeNames = names.filter((name) => !!env[name]);
+    return activeNames.length > 0
+        ? ` ${styles.secondary(`(Using ${activeNames.join(', ')})`)}`
+        : '';
+};
+const formatConfiguredProject = (projectName, projectUuid) => projectUuid === 'Not set' ? projectName : `${projectName} (${projectUuid})`;
+const getAuthStatus = async () => {
+    try {
+        const config = await (0, config_1.getConfig)();
+        const serverUrl = config.context?.serverUrl || 'Not set';
+        const organizationUuid = config.user?.organizationUuid || 'Not set';
+        const projectName = config.context?.projectName || 'Not set';
+        const projectUuid = config.context?.project || 'Not set';
+        if (!(config.context?.apiKey && config.context?.serverUrl)) {
+            return {
+                status: 'missing_credentials',
+                serverUrl,
+                organizationUuid,
+                projectName,
+                projectUuid,
+            };
+        }
+        try {
+            const user = await (0, apiClient_1.getUserContext)();
+            return {
+                status: 'authenticated',
+                serverUrl,
+                organizationUuid: user.organizationUuid || organizationUuid,
+                projectName,
+                projectUuid,
+            };
+        }
+        catch (error) {
+            return {
+                status: 'auth_failed',
+                serverUrl,
+                organizationUuid,
+                projectName,
+                projectUuid,
+                error: (0, common_1.getErrorMessage)(error),
+            };
+        }
+    }
+    catch (error) {
+        return {
+            status: 'missing_credentials',
+            serverUrl: 'Error reading config',
+            organizationUuid: 'Error reading config',
+            projectName: 'Error reading config',
+            projectUuid: 'Error reading config',
+        };
+    }
+};
+const runDbtDebug = async (projectDir, profilesDir, options = {}) => {
+    try {
+        const args = [
+            'debug',
+            '--project-dir',
+            projectDir,
+            '--profiles-dir',
+            profilesDir,
+        ];
+        if (options.defer) {
+            args.push('--defer');
+        }
+        if (options.noDefer) {
+            args.push('--no-defer');
+        }
+        if (options.state) {
+            args.push('--state', options.state);
+        }
+        const { all } = await (0, execa_1.default)('dbt', args, {
+            all: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return all || '';
+    }
+    catch (error) {
+        const msg = (0, common_1.getErrorMessage)(error);
+        return `Error running dbt debug: ${msg}`;
+    }
+};
+const diagnosticsHandler = async (options) => {
+    const startTime = Date.now();
+    let success = true;
+    globalState_1.default.setVerbose(true); // Always verbose for diagnostics
+    try {
+        console.log(styles.title('⚡️ Clary CLI Diagnostics'));
+        console.log('');
+        // CLI Version
+        console.log(styles.bold('Clary CLI Version:'));
+        console.log(`  ${env_1.CLI_VERSION}`);
+        await (0, apiClient_1.checkLightdashVersion)();
+        console.log('');
+        // Node.js Version
+        console.log(styles.bold('Node.js Version:'));
+        console.log(`  ${env_1.NODE_VERSION.major}`);
+        if (env_1.NODE_VERSION.major !== env_1.OPTIMIZED_NODE_VERSION) {
+            console.log(styles.warning(`  ⚠️ You are using Node.js version ${process.version}. Clary CLI is optimized for v${env_1.OPTIMIZED_NODE_VERSION} so you might experience issues.`));
+        }
+        console.log('');
+        // Auth Status
+        console.log(styles.bold('Authentication Status:'));
+        const authStatus = await getAuthStatus();
+        const authSourceSuffix = getEnvSourceSuffix([
+            'CLARY_API_KEY',
+            'CLARY_PROXY_AUTHORIZATION',
+        ]);
+        const instanceSourceSuffix = getEnvSourceSuffix(['CLARY_URL']);
+        const projectSourceSuffix = getEnvSourceSuffix(['CLARY_PROJECT']);
+        if (authStatus.status === 'authenticated') {
+            console.log(`  ✅ Authenticated (verified with server)${authSourceSuffix}`);
+            console.log(`  Instance: ${authStatus.serverUrl}${instanceSourceSuffix}`);
+            console.log(`  Organization: ${authStatus.organizationUuid}`);
+            console.log(`  Configured project: ${formatConfiguredProject(authStatus.projectName, authStatus.projectUuid)}${projectSourceSuffix}`);
+        }
+        else if (authStatus.status === 'auth_failed') {
+            console.log(`  ❌ Authentication check failed${authSourceSuffix}`);
+            console.log(`  Instance: ${authStatus.serverUrl}${instanceSourceSuffix}`);
+            if (authStatus.organizationUuid !== 'Not set') {
+                console.log(`  Stored organization: ${authStatus.organizationUuid}`);
+            }
+            console.log(`  Configured project: ${formatConfiguredProject(authStatus.projectName, authStatus.projectUuid)}${projectSourceSuffix}`);
+            console.log(`  Error: ${authStatus.error}`);
+        }
+        else {
+            console.log(`  ❌ Not authenticated${authSourceSuffix}`);
+            console.log(`  Instance: ${authStatus.serverUrl}${instanceSourceSuffix}`);
+            console.log(`  Configured project: ${formatConfiguredProject(authStatus.projectName, authStatus.projectUuid)}${projectSourceSuffix}`);
+        }
+        console.log('');
+        // dbt Debug (if --dbt flag is provided)
+        if (options.dbt) {
+            console.log(styles.bold('dbt Debug:'));
+            // First get dbt version
+            try {
+                const dbtVersion = await (0, getDbtVersion_1.getDbtVersion)();
+                console.log(`  dbt Version: ${dbtVersion.verboseVersion}`);
+                console.log('');
+            }
+            catch (error) {
+                console.log(`  Error getting dbt version: ${(0, common_1.getErrorMessage)(error)}`);
+                console.log('');
+            }
+            // Then run dbt debug
+            const projectDir = options.projectDir || env_1.DEFAULT_DBT_PROJECT_DIR;
+            const profilesDir = options.profilesDir || env_1.DEFAULT_DBT_PROFILES_DIR;
+            let debugCommand = `dbt debug --project-dir ${projectDir} --profiles-dir ${profilesDir}`;
+            if (options.defer)
+                debugCommand += ' --defer';
+            if (options.noDefer)
+                debugCommand += ' --no-defer';
+            if (options.state)
+                debugCommand += ` --state ${options.state}`;
+            console.log(`  Running: ${debugCommand}`);
+            console.log('');
+            const debugOutput = await runDbtDebug(projectDir, profilesDir, {
+                defer: options.defer,
+                noDefer: options.noDefer,
+                state: options.state,
+            });
+            console.log(debugOutput);
+        }
+    }
+    catch (e) {
+        success = false;
+        throw e;
+    }
+    finally {
+        await analytics_1.LightdashAnalytics.track({
+            event: 'command.executed',
+            properties: {
+                command: 'diagnostics',
+                durationMs: Date.now() - startTime,
+                success,
+            },
+        });
+    }
+};
+exports.diagnosticsHandler = diagnosticsHandler;

package/dist/handlers/download.d.ts

@@ -0,0 +1,29 @@
+import { type SpaceAsCode } from '@lightdash/common';
+export type DownloadHandlerOptions = {
+    verbose: boolean;
+    charts: string[];
+    dashboards: string[];
+    force: boolean;
+    path?: string;
+    project?: string;
+    languageMap: boolean;
+    skipSpaceCreate: boolean;
+    public: boolean;
+    includeCharts: boolean;
+    nested: boolean;
+    skipSpaces: boolean;
+    validate?: boolean;
+    concurrency: number;
+    gzip?: boolean;
+};
+type MetadataEntry = {
+    slug: string;
+    type: 'charts' | 'dashboards';
+    downloadedAt: string;
+};
+type DownloadContentType = 'charts' | 'dashboards' | 'sqlCharts';
+export declare const downloadContent: (ids: string[], type: DownloadContentType, projectId: string, projectName: string, customPath?: string, languageMap?: boolean, nested?: boolean, skipSpaces?: boolean) => Promise<[number, string[], MetadataEntry[], SpaceAsCode[]]>;
+export declare const downloadHandler: (options: DownloadHandlerOptions) => Promise<void>;
+export declare const uploadHandler: (options: DownloadHandlerOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=download.d.ts.map

package/dist/handlers/download.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"download.d.ts","sourceRoot":"","sources":["../../src/handlers/download.ts"],"names":[],"mappings":"AAEA,OAAO,EAmBH,KAAK,WAAW,EACnB,MAAM,mBAAmB,CAAC;AAuB3B,MAAM,MAAM,sBAAsB,GAAG;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AA2FF,KAAK,aAAa,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,YAAY,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;CACxB,CAAC;AAwbF,KAAK,mBAAmB,GAAG,QAAQ,GAAG,YAAY,GAAG,WAAW,CAAC;AAkDjE,eAAO,MAAM,eAAe,GACxB,KAAK,MAAM,EAAE,EACb,MAAM,mBAAmB,EACzB,WAAW,MAAM,EACjB,aAAa,MAAM,EACnB,aAAa,MAAM,EACnB,cAAa,OAAe,EAC5B,SAAQ,OAAe,EACvB,aAAY,OAAe,KAC5B,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,aAAa,EAAE,EAAE,WAAW,EAAE,CAAC,CA0H5D,CAAC;AAEF,eAAO,MAAM,eAAe,GACxB,SAAS,sBAAsB,KAChC,OAAO,CAAC,IAAI,CAoOd,CAAC;AAubF,eAAO,MAAM,aAAa,GACtB,SAAS,sBAAsB,KAChC,OAAO,CAAC,IAAI,CA2Kd,CAAC"}