@dcl/sdk-commands 7.1.4-4542949081.commit-c326cfb → 7.1.4-4544451404.commit-3e8cb7c

package/dist/components/analytics.js

@@ -8,75 +8,70 @@ const uuid_1 = require("uuid");
 const analytics_node_1 = require("@segment/analytics-node");
 const fp_future_1 = __importDefault(require("fp-future"));
 const log_1 = require("./log");
-async function createAnalyticsComponent({ dclInfoConfig, logger }) {
+const config_1 = require("./config");
+const config_2 = require("../logic/config");
+const noopAnalytics = {
+    track() { },
+    async stop() { }
+};
+async function createAnalyticsComponent(components) {
+    const analyticsEnabled = (await (0, config_1.readStringConfig)(components, 'DCL_DISABLE_ANALYTICS')) !== 'true';
+    if (!analyticsEnabled) {
+        return noopAnalytics;
+    }
     const USER_ID = 'sdk-commands-user';
-    const config = await dclInfoConfig.get();
-    const analytics = new analytics_node_1.Analytics({ writeKey: config.segmentKey ?? '' });
+    let anonId = await (0, config_1.readStringConfig)(components, 'DCL_ANON_ID');
+    const analytics = new analytics_node_1.Analytics({ writeKey: (0, config_2.getSegmentKey)() });
+    if (!anonId) {
+        anonId = (0, uuid_1.v4)();
+        await (0, config_1.writeGlobalConfig)(components, 'DCL_ANON_ID', anonId);
+        analytics.identify({
+            userId: USER_ID,
+            traits: {
+                devId: anonId,
+                createdAt: new Date()
+            }
+        });
+        components.logger.info([
+            `By default, Decentraland CLI sends anonymous usage stats to improve the products, if you want to disable it, add the following line to the configuration file at ${log_1.colors.bold((0, config_1.getGlobalDclRcPath)())}.`,
+            `  DCL_DISABLE_ANALYTICS=true`,
+            `More info https://dcl.gg/sdk/analytics`
+        ].join('\n'));
+    }
     const promises = [];
-    async function track(eventName, eventProps) {
-        const trackFuture = (0, fp_future_1.default)();
-        const { userId, trackStats } = await dclInfoConfig.get();
-        const version = await dclInfoConfig.getVersion();
-        if (!trackStats) {
-            return trackFuture.resolve();
+    const sdkVersion = await (0, config_2.getInstalledPackageVersion)(components, '@dcl/sdk', process.cwd());
+    // the following properties are added to every telemetry report
+    const baseTelemetryProperties = {
+        os: process.platform,
+        nodeVersion: process.version,
+        cliVersion: await (0, config_2.getSdkCommandsVersion)(),
+        isCI: (0, config_2.isCI)(),
+        isEditor: (0, config_2.isEditor)(),
+        devId: anonId,
+        ecs: {
+            ecsVersion: 'ecs7',
+            packageVersion: sdkVersion
         }
+    };
+    function track(eventName, eventProps) {
+        const trackFuture = (0, fp_future_1.default)();
         const trackInfo = {
             userId: USER_ID,
             event: eventName,
             properties: {
                 ...eventProps,
-                os: process.platform,
-                nodeVersion: process.version,
-                cliVersion: version,
-                isCI: dclInfoConfig.isCI(),
-                isEditor: dclInfoConfig.isEditor(),
-                devId: userId,
-                ecs: {
-                    ecsVersion: 'ecs7',
-                    packageVersion: version
-                }
+                ...baseTelemetryProperties
             }
         };
         analytics.track(trackInfo, () => {
             trackFuture.resolve();
         });
-        if (!dclInfoConfig.isProduction()) {
-            // TODO: what is this supposed to do?
-            logger.info('TrackingInfo: ' + JSON.stringify(trackInfo));
-        }
-        return trackFuture;
+        promises.push(trackFuture);
     }
     return {
         get() {
             return analytics;
         },
-        async identify() {
-            if (config.userId && !config.trackStats) {
-                return;
-            }
-            const userId = config.userId ?? (0, uuid_1.v4)();
-            let dclInfo = {};
-            if (!config.userId) {
-                dclInfo = { userId, trackStats: true };
-                logger.info(`Decentraland CLI sends anonymous usage stats to improve their products, if you want to disable it change the configuration at ${log_1.colors.bold('~/.dclinfo')}\n`);
-            }
-            if (!config.userIdentified) {
-                dclInfo.userIdentified = true;
-                analytics.identify({
-                    userId: USER_ID,
-                    traits: {
-                        devId: userId,
-                        createdAt: new Date()
-                    }
-                });
-            }
-            if (Object.keys(dclInfo).length) {
-                await dclInfoConfig.updateDCLInfo(dclInfo);
-            }
-        },
-        trackSync(eventName, eventProps) {
-            promises.push(track(eventName, eventProps));
-        },
         track,
         async stop() {
             await Promise.all(promises);

package/dist/components/config.d.ts

@@ -0,0 +1,18 @@
+import { CliComponents } from '.';
+import { IFileSystemComponent } from './fs';
+export type ConfigKeys = 'DCL_ANON_ID' | 'DCL_DISABLE_ANALYTICS' | 'DCL_LAND_REGISTRY_ADDRESS' | 'DCL_ESTATE_REGISTRY_ADDRESS' | 'DCL_CATALYST';
+export declare const DCL_RC = ".dclrc";
+/**
+ * This function creates a chained .env loader for configurations.
+ * It loads sdk-commands/.dclrc then ~/.dclrc and lastly $(pwd)/.dclrc
+ * By default, process.env overrides any configuration.
+ */
+export declare function createConfigComponent({ fs }: {
+    fs: IFileSystemComponent;
+}): Promise<import("@well-known-components/interfaces").IConfigComponent>;
+export declare function writeGlobalConfig({ fs }: {
+    fs: IFileSystemComponent;
+}, key: ConfigKeys, value: string): Promise<void>;
+export declare function getGlobalDclRcPath(): string;
+export declare function readStringConfig(components: Pick<CliComponents, 'config'>, key: ConfigKeys): Promise<string | undefined>;
+export declare function requireStringConfig(components: Pick<CliComponents, 'config'>, key: ConfigKeys): Promise<string>;

package/dist/components/config.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireStringConfig = exports.readStringConfig = exports.getGlobalDclRcPath = exports.writeGlobalConfig = exports.createConfigComponent = exports.DCL_RC = void 0;
+const env_config_provider_1 = require("@well-known-components/env-config-provider");
+const os_1 = require("os");
+const path_1 = __importDefault(require("path"));
+const error_1 = require("../logic/error");
+exports.DCL_RC = '.dclrc';
+/**
+ * This function creates a chained .env loader for configurations.
+ * It loads sdk-commands/.dclrc then ~/.dclrc and lastly $(pwd)/.dclrc
+ * By default, process.env overrides any configuration.
+ */
+async function createConfigComponent({ fs }) {
+    const dotEnvFilesToLoad = [await getSdkCommandsDclRcPath(fs)];
+    const userDclRc = getGlobalDclRcPath();
+    if (await fs.fileExists(userDclRc))
+        dotEnvFilesToLoad.push(userDclRc);
+    const projectDclRc = exports.DCL_RC;
+    /* istanbul ignore if */
+    if (await fs.fileExists(projectDclRc))
+        dotEnvFilesToLoad.push(projectDclRc);
+    return (0, env_config_provider_1.createDotEnvConfigComponent)({ path: dotEnvFilesToLoad });
+}
+exports.createConfigComponent = createConfigComponent;
+async function writeGlobalConfig({ fs }, key, value) {
+    const data = ['', '# ' + new Date().toISOString(), key + '=' + value, ''];
+    await fs.appendFile(getGlobalDclRcPath(), data.join('\n'));
+}
+exports.writeGlobalConfig = writeGlobalConfig;
+function getGlobalDclRcPath() {
+    return path_1.default.resolve((0, os_1.homedir)(), exports.DCL_RC);
+}
+exports.getGlobalDclRcPath = getGlobalDclRcPath;
+async function getSdkCommandsDclRcPath(fs) {
+    const dclRc = path_1.default.resolve(__dirname, '..', '..', exports.DCL_RC);
+    /* istanbul ignore if */
+    if (!(await fs.fileExists(dclRc))) {
+        throw new Error(dclRc + ' not found');
+    }
+    return dclRc;
+}
+async function readStringConfig(components, key) {
+    return components.config.getString(key);
+}
+exports.readStringConfig = readStringConfig;
+async function requireStringConfig(components, key) {
+    const address = await readStringConfig(components, key);
+    if (!address)
+        throw new error_1.CliError(`configuration ${key} was not provided`);
+    return address;
+}
+exports.requireStringConfig = requireStringConfig;

package/dist/components/exit-signal.d.ts

@@ -0,0 +1,5 @@
+import { IBaseComponent } from '@well-known-components/interfaces';
+export type ISignalerComponent = {
+    programClosed: Promise<void>;
+};
+export declare function createExitSignalComponent(): IBaseComponent & ISignalerComponent;

package/dist/components/exit-signal.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExitSignalComponent = void 0;
+const fp_future_1 = __importDefault(require("fp-future"));
+// this component exists to "await program stopped" at the end of Lifecycle.main
+function createExitSignalComponent() {
+    const programClosed = (0, fp_future_1.default)();
+    const signaler = {
+        programClosed,
+        async stop() {
+            // this promise is resolved upon SIGTERM or SIGHUP
+            // or when program.stop is called
+            programClosed.resolve();
+        }
+    };
+    return signaler;
+}
+exports.createExitSignalComponent = createExitSignalComponent;

package/dist/components/fs.d.ts

@@ -7,7 +7,7 @@ import * as fsPromises from 'fs/promises';
  *
  * This may be moved to well-known-components in the future
  */
-export type IFileSystemComponent = Pick<typeof fs, 'createReadStream'> & Pick<typeof fs, 'createWriteStream'> & Pick<typeof fsPromises, 'access' | 'opendir' | 'stat' | 'unlink' | 'mkdir' | 'readFile' | 'writeFile' | 'rename' | 'rmdir'> & {
+export type IFileSystemComponent = Pick<typeof fs, 'createReadStream'> & Pick<typeof fs, 'createWriteStream'> & Pick<typeof fsPromises, 'access' | 'opendir' | 'stat' | 'unlink' | 'mkdir' | 'readFile' | 'writeFile' | 'rename' | 'rmdir' | 'appendFile'> & {
     constants: Pick<typeof fs.constants, 'F_OK' | 'R_OK'>;
 } & {
     fileExists(path: string): Promise<boolean>;

package/dist/components/fs.js

@@ -51,6 +51,7 @@ function createFsComponent() {
         createReadStream: fs.createReadStream,
         createWriteStream: fs.createWriteStream,
         access: fsPromises.access,
+        appendFile: fsPromises.appendFile,
         writeFile: fsPromises.writeFile,
         opendir: fsPromises.opendir,
         stat: fsPromises.stat,

package/dist/components/index.d.ts

@@ -1,13 +1,14 @@
-import { ILoggerComponent } from '@well-known-components/interfaces';
+import { ILoggerComponent, IConfigComponent } from '@well-known-components/interfaces';
+import { IProcessSpawnerComponent } from '../logic/exec';
 import { IAnalyticsComponent } from './analytics';
-import { IDCLInfoConfigComponent } from './dcl-info-config';
 import { IFetchComponent } from './fetch';
 import { IFileSystemComponent } from './fs';
 export type CliComponents = {
     fs: IFileSystemComponent;
     fetch: IFetchComponent;
     logger: ILoggerComponent.ILogger;
-    dclInfoConfig: IDCLInfoConfigComponent;
     analytics: IAnalyticsComponent;
+    spawner: IProcessSpawnerComponent;
+    config: IConfigComponent;
 };
 export declare function initComponents(): Promise<CliComponents>;

package/dist/components/index.js

@@ -1,21 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initComponents = void 0;
+const child_process_1 = require("child_process");
+const exec_1 = require("../logic/exec");
 const analytics_1 = require("./analytics");
-const dcl_info_config_1 = require("./dcl-info-config");
+const config_1 = require("./config");
 const fetch_1 = require("./fetch");
 const fs_1 = require("./fs");
 const log_1 = require("./log");
 async function initComponents() {
-    const fsComponent = (0, fs_1.createFsComponent)();
-    const dclInfoConfig = await (0, dcl_info_config_1.createDCLInfoConfigComponent)({ fs: fsComponent });
+    const fs = (0, fs_1.createFsComponent)();
+    const config = await (0, config_1.createConfigComponent)({ fs });
     const logger = (0, log_1.createStderrCliLogger)();
+    const spawner = (0, exec_1.createProcessSpawnerComponent)(child_process_1.spawn);
     return {
-        fs: fsComponent,
+        fs,
         fetch: (0, fetch_1.createFetchComponent)(),
         logger,
-        dclInfoConfig,
-        analytics: await (0, analytics_1.createAnalyticsComponent)({ dclInfoConfig, logger })
+        config,
+        spawner,
+        analytics: await (0, analytics_1.createAnalyticsComponent)({ config, logger, fs })
     };
 }
 exports.initComponents = initComponents;

package/dist/index.js

@@ -36,7 +36,6 @@ async function main() {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const cmd = require(`${commands_1.COMMANDS_PATH}/${command}`);
     if (commandFnsAreValid(cmd)) {
-        await components.analytics.identify();
         const options = { args: cmd.args, components };
         if (needsHelp) {
             await cmd.help(options);
@@ -66,5 +65,5 @@ main().catch(function handleError(err) {
         (0, log_1.writeToStderr)(`Developer: All errors thrown must be an instance of "CliError"`);
     }
     // set an exit code but not finish the program immediately to close any pending work
-    process.exitCode = 1;
+    process.exit(process.exitCode ?? 1);
 });

package/dist/logic/bundle.d.ts

@@ -0,0 +1,51 @@
+import esbuild from 'esbuild';
+import { CliComponents } from '../components';
+export type BundleComponents = Pick<CliComponents, 'logger' | 'fs'>;
+export type SceneJson = {
+    main: string;
+    runtimeVersion: string;
+};
+export type CompileOptions = {
+    production: boolean;
+    watch: boolean;
+    single?: string;
+    workingDirectory: string;
+    emitDeclaration: boolean;
+};
+export declare function bundleProject(components: BundleComponents, options: CompileOptions): Promise<{
+    context: esbuild.BuildContext<{
+        entryPoints: string[];
+        bundle: true;
+        platform: "browser";
+        format: "cjs";
+        preserveSymlinks: false;
+        outfile: string;
+        allowOverwrite: false;
+        sourcemap: "external" | "inline";
+        minify: boolean;
+        minifyIdentifiers: boolean;
+        minifySyntax: boolean;
+        minifyWhitespace: boolean;
+        treeShaking: true;
+        metafile: true;
+        absWorkingDir: string;
+        target: string;
+        external: string[];
+        sourceRoot: string;
+        define: {
+            document: string;
+            window: string;
+            DEBUG: string;
+            'globalThis.DEBUG': string;
+            'process.env.NODE_ENV': string;
+        };
+        tsconfig: string;
+        supported: {
+            'import-assertions': false;
+            'import-meta': false;
+            'dynamic-import': false;
+            hashbang: false;
+        };
+    }>;
+    sceneJson: import("@dcl/schemas").Scene;
+}>;

package/dist/logic/bundle.js

@@ -0,0 +1,120 @@
+"use strict";
+// this file is tested extensively to build scenes in the `make test` command
+// but since it runs outiside the testing harness, coverage is not collected
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleProject = void 0;
+/* istanbul ignore file */
+const esbuild_1 = __importDefault(require("esbuild"));
+const child_process_1 = __importDefault(require("child_process"));
+const fp_future_1 = require("fp-future");
+const error_1 = require("./error");
+const scene_validations_1 = require("./scene-validations");
+const path_1 = require("path");
+const beautiful_logs_1 = require("./beautiful-logs");
+const log_1 = require("../components/log");
+const url_1 = require("url");
+const MAX_STEP = 3;
+async function bundleProject(components, options) {
+    const sceneJson = await (0, scene_validations_1.getValidSceneJson)(components, options.workingDirectory);
+    const tsconfig = (0, path_1.join)(options.workingDirectory, 'tsconfig.json');
+    (0, beautiful_logs_1.printProgressStep)(components.logger, `Validating project structure`, 1, MAX_STEP);
+    if (!options.single && !sceneJson.main) {
+        throw new error_1.CliError('scene.json .main must be present');
+    }
+    if (sceneJson.runtimeVersion !== '7') {
+        throw new error_1.CliError('scene.json `"runtimeVersion": "7"` must be present');
+    }
+    if (!(await components.fs.fileExists(tsconfig))) {
+        throw new error_1.CliError(`File ${tsconfig} must exist to compile the Typescript project`);
+    }
+    const input = options.single ?? 'src/index.ts';
+    const output = !options.single ? sceneJson.main : options.single.replace(/\.ts$/, '.js');
+    const outfile = (0, path_1.join)(options.workingDirectory, output);
+    (0, beautiful_logs_1.printProgressStep)(components.logger, `Bundling file ${log_1.colors.bold(input)}`, 2, MAX_STEP);
+    const context = await esbuild_1.default.context({
+        entryPoints: [input],
+        bundle: true,
+        platform: 'browser',
+        format: 'cjs',
+        preserveSymlinks: false,
+        outfile,
+        allowOverwrite: false,
+        sourcemap: options.production ? 'external' : 'inline',
+        minify: options.production,
+        minifyIdentifiers: options.production,
+        minifySyntax: options.production,
+        minifyWhitespace: options.production,
+        treeShaking: true,
+        metafile: true,
+        absWorkingDir: options.workingDirectory,
+        target: 'es2020',
+        external: ['~system/*'],
+        // convert filesystem paths into file:// to enable VSCode debugger
+        sourceRoot: (0, url_1.pathToFileURL)((0, path_1.dirname)(outfile)).toString(),
+        define: {
+            document: 'undefined',
+            window: 'undefined',
+            DEBUG: options.production ? 'false' : 'true',
+            'globalThis.DEBUG': options.production ? 'false' : 'true',
+            'process.env.NODE_ENV': JSON.stringify(options.production ? 'production' : 'development')
+        },
+        tsconfig: (0, path_1.join)(options.workingDirectory, 'tsconfig.json'),
+        supported: {
+            'import-assertions': false,
+            'import-meta': false,
+            'dynamic-import': false,
+            hashbang: false
+        }
+    });
+    if (options.watch) {
+        await context.watch({});
+    }
+    else {
+        try {
+            await context.rebuild();
+        }
+        catch (err) {
+            throw new error_1.CliError(err.toString());
+        }
+        await context.dispose();
+    }
+    (0, beautiful_logs_1.printProgressInfo)(components.logger, `Bundle saved ${log_1.colors.bold(output)}`);
+    if (options.watch)
+        (0, beautiful_logs_1.printProgressInfo)(components.logger, `The compiler is watching for changes`);
+    await runTypeChecker(components, options);
+    return { context, sceneJson };
+}
+exports.bundleProject = bundleProject;
+function runTypeChecker(components, options) {
+    const args = [
+        require.resolve('typescript/lib/tsc'),
+        '-p',
+        'tsconfig.json',
+        '--preserveWatchOutput',
+        options.emitDeclaration ? '--emitDeclarationOnly' : '--noEmit'
+    ];
+    if (options.watch)
+        args.push('--watch');
+    (0, beautiful_logs_1.printProgressStep)(components.logger, `Running type checker`, 3, MAX_STEP);
+    const ts = child_process_1.default.spawn('node', args, { env: process.env, cwd: options.workingDirectory });
+    const typeCheckerFuture = (0, fp_future_1.future)();
+    ts.on('close', (code) => {
+        if (code === 0) {
+            (0, beautiful_logs_1.printProgressInfo)(components.logger, `Type checking completed without errors`);
+        }
+        else {
+            typeCheckerFuture.reject(new error_1.CliError(`Typechecker exited with code ${code}.`));
+            return;
+        }
+        typeCheckerFuture.resolve(code);
+    });
+    ts.stdout.pipe(process.stdout);
+    ts.stderr.pipe(process.stderr);
+    if (options.watch) {
+        typeCheckerFuture.resolve(-1);
+    }
+    return typeCheckerFuture;
+}

package/dist/logic/catalyst-requests.d.ts

@@ -1,5 +1,20 @@
 import { Entity } from '@dcl/schemas';
-export declare function fetchEntityByPointer(baseUrl: string, pointers: string[]): Promise<{
+import { CliComponents } from '../components';
+export type DAOCatalyst = {
+    baseUrl: string;
+    owner: string;
+    id: string;
+};
+type CatalystInfo = {
+    url: string;
+    timestamp: number;
+    entityId: string;
+};
+export type Network = 'mainnet' | 'goerli';
+export declare function daoCatalysts(components: Pick<CliComponents, 'fetch' | 'config'>, network: Network): Promise<Array<DAOCatalyst>>;
+export declare function fetchEntityByPointer({ fetch }: Pick<CliComponents, 'fetch'>, baseUrl: string, pointers: string[]): Promise<{
     baseUrl: string;
     deployments: Entity[];
 }>;
+export declare function getPointers(components: Pick<CliComponents, 'fetch' | 'logger' | 'config'>, pointer: string, network: Network): Promise<CatalystInfo[]>;
+export {};

package/dist/logic/catalyst-requests.js

@@ -1,15 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchEntityByPointer = void 0;
-const undici_1 = require("undici");
-async function fetchEntityByPointer(baseUrl, pointers) {
+exports.getPointers = exports.fetchEntityByPointer = exports.daoCatalysts = void 0;
+const config_1 = require("./config");
+async function daoCatalysts(components, network) {
+    const tld = network === 'mainnet' ? 'org' : 'zone';
+    const catalystUrl = network === 'mainnet' ? await (0, config_1.getCatalystBaseUrl)(components) : `https://peer.decentraland.${tld}`;
+    const resp = await (await components.fetch.fetch(`${catalystUrl}/lambdas/contracts/servers`)).json();
+    return resp;
+}
+exports.daoCatalysts = daoCatalysts;
+async function fetchEntityByPointer({ fetch }, baseUrl, pointers) {
     if (pointers.length === 0)
         return {
             baseUrl,
             deployments: []
         };
     const activeEntities = baseUrl + '/content/entities/active';
-    const response = await (0, undici_1.fetch)(activeEntities, {
+    const response = await fetch.fetch(activeEntities, {
         method: 'post',
         headers: { 'content-type': 'application/json', connection: 'close' },
         body: JSON.stringify({ pointers })
@@ -21,3 +28,20 @@ async function fetchEntityByPointer(baseUrl, pointers) {
     };
 }
 exports.fetchEntityByPointer = fetchEntityByPointer;
+async function getPointers(components, pointer, network) {
+    const catalysts = await daoCatalysts(components, network);
+    const catalystInfo = [];
+    for (const { baseUrl } of catalysts) {
+        try {
+            const result = await fetchEntityByPointer(components, baseUrl, [pointer]);
+            const timestamp = result.deployments[0]?.timestamp;
+            const entityId = result.deployments[0]?.id || '';
+            catalystInfo.push({ timestamp, entityId, url: baseUrl });
+        }
+        catch (err) {
+            components.logger.log('Error fetching catalyst pointers', err);
+        }
+    }
+    return catalystInfo;
+}
+exports.getPointers = getPointers;

package/dist/logic/config.d.ts

@@ -1,12 +1,20 @@
 import { CliComponents } from '../components';
-import { DCLInfo } from './dcl-info';
-export declare const getDclInfoPath: () => string;
 /**
- * Reads the contents of the `.dclinfo` file
+ * Returns the version of the sdk-commands that is running
  */
-export declare function getDCLInfoConfig(components: Pick<CliComponents, 'fs'>): Promise<DCLInfo>;
+export declare function getSdkCommandsVersion(): Promise<any>;
 /**
- * Config that can be override via ENV variables
+ * Returns the installed version of a certain package in the current working directory.
+ * Returns "unknown" if the package is not installed.
  */
-export declare function getEnvConfig(): Partial<DCLInfo>;
-export declare function removeEmptyKeys(obj: Record<string, unknown>): Record<string, unknown>;
+export declare function getInstalledPackageVersion(components: Pick<CliComponents, 'fs'>, packageName: string, workingDirectory: string): Promise<string>;
+/**
+ * Returns true if the Decentraland Editor is running.
+ * TODO: EDITOR is a unix reserved env var. Change it for something more specific.
+ */
+export declare function isEditor(): boolean;
+export declare function isCI(): boolean;
+export declare function getCatalystBaseUrl(components: Pick<CliComponents, 'config'>): Promise<string>;
+export declare function getSegmentKey(): "sFdziRVDJo0taOnGzTZwafEL9nLIANZ3" | "mjCV5Dc4VAKXLJAH5g7LyHyW1jrIR3to";
+export declare function getLandRegistry(components: Pick<CliComponents, 'config'>): Promise<string>;
+export declare function getEstateRegistry(components: Pick<CliComponents, 'config'>): Promise<string>;