@dcl/sdk-commands 7.0.0-4294380152.commit-0d08b10 → 7.0.0-4295573637.commit-6d503ad

package/dist/commands/build/index.js

@@ -53,7 +53,7 @@ async function main(options) {
     if (!watch) {
         watchingFuture.resolve(null);
     }
-    const sceneJson = await (0, project_files_1.getSceneJson)(options.components, projectRoot);
+    const sceneJson = await (0, scene_validations_1.getValidSceneJson)(options.components, projectRoot);
     const coords = (0, scene_validations_1.getBaseCoords)(sceneJson);
     await options.components.analytics.track('Build scene', {
         projectHash: await (0, project_files_1.b64HashingFunction)(projectRoot),

package/dist/commands/deploy/index.d.ts

@@ -0,0 +1,31 @@
+import { CliComponents } from '../../components';
+interface Options {
+    args: typeof args;
+    components: CliComponents;
+}
+export declare const args: import("arg").Result<{
+    '--help': BooleanConstructor;
+    '--json': BooleanConstructor;
+    '-h': string;
+} & {
+    '--dir': StringConstructor;
+    '--help': BooleanConstructor;
+    '-h': string;
+    '--target': StringConstructor;
+    '-t': string;
+    '--target-content': StringConstructor;
+    '-tc': string;
+    '--skip-validations': BooleanConstructor;
+    '--skip-version-checks': BooleanConstructor;
+    '--skip-build': BooleanConstructor;
+    '--https': BooleanConstructor;
+    '--force-upload': BooleanConstructor;
+    '--yes': BooleanConstructor;
+    '--no-browser': BooleanConstructor;
+    '-b': string;
+    '--port': NumberConstructor;
+    '-p': string;
+}>;
+export declare function help(): string;
+export declare function main(options: Options): Promise<void>;
+export {};

package/dist/commands/deploy/index.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = exports.help = exports.args = void 0;
+const path_1 = require("path");
+const schemas_1 = require("@dcl/schemas");
+const dcl_catalyst_client_1 = require("dcl-catalyst-client");
+const crypto_1 = require("@dcl/crypto");
+const eth_connect_1 = require("eth-connect");
+const crypto_2 = require("@dcl/crypto/dist/crypto");
+const build_1 = require("../build");
+const scene_validations_1 = require("../../logic/scene-validations");
+const args_1 = require("../../logic/args");
+const project_validations_1 = require("../../logic/project-validations");
+const api_1 = require("./linker-dapp/api");
+const error_1 = require("../../logic/error");
+const beautiful_logs_1 = require("../../logic/beautiful-logs");
+const account_1 = require("../../logic/account");
+exports.args = (0, args_1.getArgs)({
+    '--dir': String,
+    '--help': Boolean,
+    '-h': '--help',
+    '--target': String,
+    '-t': '--target',
+    '--target-content': String,
+    '-tc': '--target-content',
+    '--skip-validations': Boolean,
+    '--skip-version-checks': Boolean,
+    '--skip-build': Boolean,
+    '--https': Boolean,
+    '--force-upload': Boolean,
+    '--yes': Boolean,
+    '--no-browser': Boolean,
+    '-b': '--no-browser',
+    '--port': Number,
+    '-p': '--port'
+});
+function help() {
+    return `
+  Usage: 'sdk-commands build [options]'
+    Options:
+      -h, --help                Displays complete help
+      -p, --port        [port]  Select a custom port for the development server
+      -t, --target              Specifies the address and port for the target catalyst server. Defaults to peer.decentraland.org
+      -t, --target-content      Specifies the address and port for the target content server. Example: 'peer.decentraland.org/content'. Can't be set together with --target
+      -b, --no-browser          Do not open a new browser window
+      --skip-version-checks     Skip the ECS and CLI version checks, avoid the warning message and launch anyway
+      --skip-build              Skip build before deploy
+      --skip-validations        Skip permissions verifications on the client side when deploying content
+
+    Example:
+    - Deploy your scene:
+      $ sdk-commands deploy
+    - Deploy your scene to a specific content server:
+      $ sdk-commands deploy --target my-favorite-catalyst-server.org:2323
+`;
+}
+exports.help = help;
+async function main(options) {
+    const dir = (0, path_1.resolve)(process.cwd(), options.args['--dir'] || '.');
+    const openBrowser = !options.args['--no-browser'];
+    const skipBuild = options.args['--skip-build'];
+    const linkerPort = options.args['--port'];
+    const { error } = options.components.logger;
+    const comps = { components: options.components };
+    if (!skipBuild) {
+        await (0, project_validations_1.npmRun)(dir, 'build');
+    }
+    await (0, build_1.main)({ args: { '--dir': dir }, ...comps });
+    if (options.args['--target'] && options.args['--target-content']) {
+        throw new error_1.CliError(`You can't set both the 'target' and 'target-content' arguments.`);
+    }
+    // Obtain list of files to deploy
+    const files = await (0, scene_validations_1.getFiles)(options.components, dir);
+    (0, scene_validations_1.validateFilesSizes)(files);
+    const contentFiles = new Map(files.map((file) => [file.path, file.content]));
+    const sceneJson = await (0, scene_validations_1.getValidSceneJson)(options.components, dir);
+    const { entityId, files: entityFiles } = await dcl_catalyst_client_1.DeploymentBuilder.buildEntity({
+        type: schemas_1.EntityType.SCENE,
+        pointers: sceneJson.scene.parcels,
+        files: contentFiles,
+        metadata: sceneJson
+    });
+    // Signing message
+    const messageToSign = entityId;
+    const { signature, address, chainId } = await getAddressAndSignature(options.components, messageToSign, sceneJson, files, {
+        openBrowser,
+        linkerPort,
+        isHttps: !!options.args['--https'],
+        skipValidations: !!options.args['--skip-validations'] || !!options.args['--target'] || !!options.args['--target-content']
+    });
+    const authChain = crypto_1.Authenticator.createSimpleAuthChain(entityId, address, signature);
+    // Uploading data
+    const catalyst = await getCatalyst(options.args['--target'], options.args['--target-content']);
+    (0, beautiful_logs_1.printProgressInfo)(options.components.logger, `Uploading data to: ${catalyst.getContentUrl()}...`);
+    const deployData = { entityId, files: entityFiles, authChain };
+    const position = sceneJson.scene.base;
+    const network = chainId === schemas_1.ChainId.ETHEREUM_GOERLI ? 'goerli' : 'mainnet';
+    const sceneUrl = `https://play.decentraland.org/?NETWORK=${network}&position=${position}`;
+    try {
+        const response = (await catalyst.deploy(deployData, {
+            timeout: '10m'
+        }));
+        if (response.message) {
+            (0, beautiful_logs_1.printProgressInfo)(options.components.logger, response.message);
+        }
+        (0, beautiful_logs_1.printSuccess)(options.components.logger, 'Content uploaded', sceneUrl);
+    }
+    catch (e) {
+        error('Could not upload content:');
+        console.log(e);
+    }
+}
+exports.main = main;
+async function getCatalyst(target, targetContent) {
+    if (target) {
+        return new dcl_catalyst_client_1.CatalystClient({ catalystUrl: target.endsWith('/') ? target.slice(0, -1) : target });
+    }
+    if (targetContent) {
+        return new dcl_catalyst_client_1.ContentClient({ contentUrl: targetContent });
+    }
+    return dcl_catalyst_client_1.CatalystClient.connectedToCatalystIn({ network: 'mainnet' });
+}
+async function getAddressAndSignature(components, messageToSign, scene, files, linkOptions) {
+    if (process.env.DCL_PRIVATE_KEY) {
+        const wallet = (0, account_1.createWallet)(process.env.DCL_PRIVATE_KEY);
+        const signature = (0, crypto_2.ethSign)((0, eth_connect_1.hexToBytes)(wallet.privateKey), messageToSign);
+        return { signature, address: wallet.address };
+    }
+    const { linkerPort, ...opts } = linkOptions;
+    return (0, api_1.runLinkerApp)(components, scene, files, linkerPort, messageToSign, opts);
+}

package/dist/commands/deploy/linker-dapp/api.d.ts

@@ -0,0 +1,24 @@
+import { ChainId, Scene } from '@dcl/schemas';
+import { IFile } from '../../../logic/scene-validations';
+import { CliComponents } from '../../../components';
+export interface LinkerResponse {
+    address: string;
+    signature: string;
+    chainId?: ChainId;
+}
+export interface SceneInfo {
+    baseParcel: string;
+    parcels: string[];
+    rootCID: string;
+    landRegistry?: string;
+    estateRegistry?: string;
+    debug: boolean;
+    title?: string;
+    description?: string;
+    skipValidations: boolean;
+}
+export declare function runLinkerApp(cliComponents: Pick<CliComponents, 'fs' | 'logger' | 'fetch'>, scene: Scene, files: IFile[], port: number, rootCID: string, { isHttps, skipValidations, openBrowser }: {
+    isHttps: boolean;
+    skipValidations: boolean;
+    openBrowser: boolean;
+}): Promise<LinkerResponse>;

package/dist/commands/deploy/linker-dapp/api.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLinkerApp = void 0;
+const http_server_1 = require("@well-known-components/http-server");
+const interfaces_1 = require("@well-known-components/interfaces");
+const env_config_provider_1 = require("@well-known-components/env-config-provider");
+const logger_1 = require("@well-known-components/logger");
+const path_1 = require("path");
+const schemas_1 = require("@dcl/schemas");
+const querystring_1 = __importDefault(require("querystring"));
+const open_1 = __importDefault(require("open"));
+const get_free_port_1 = require("../../../logic/get-free-port");
+const dcl_info_1 = require("../../../logic/dcl-info");
+const beautiful_logs_1 = require("../../../logic/beautiful-logs");
+const routes_1 = require("./routes");
+function runLinkerApp(cliComponents, scene, files, port, rootCID, { isHttps, skipValidations, openBrowser }) {
+    return new Promise(async (resolve) => {
+        const { logger } = cliComponents;
+        const resolvedPort = await (0, get_free_port_1.getPort)(port, 4044);
+        const sceneInfo = await getSceneInfo(scene, rootCID, skipValidations);
+        const protocol = isHttps ? 'https' : 'http';
+        const queryParams = querystring_1.default.stringify(sceneInfo);
+        const url = `${protocol}://localhost:${resolvedPort}`;
+        const program = await interfaces_1.Lifecycle.run({
+            async initComponents() {
+                const config = (0, env_config_provider_1.createRecordConfigComponent)({
+                    HTTP_SERVER_PORT: resolvedPort.toString(),
+                    HTTP_SERVER_HOST: '0.0.0.0',
+                    ...process.env
+                });
+                const logs = await (0, logger_1.createConsoleLogComponent)({});
+                const components = { config, logs };
+                const https = isHttps ? await getCredentials(cliComponents) : undefined;
+                const server = await (0, http_server_1.createServerComponent)(components, { https });
+                return { config, logs, server };
+            },
+            async main({ components, startComponents }) {
+                const { router, futureSignature } = (0, routes_1.setRoutes)(cliComponents, files, sceneInfo);
+                components.server.setContext(components);
+                components.server.use(router.allowedMethods());
+                components.server.use(router.middleware());
+                console.log('\x1Bc');
+                await startComponents();
+                if (openBrowser)
+                    await browse(cliComponents, url, queryParams);
+                const value = await futureSignature;
+                (0, beautiful_logs_1.printSuccess)(cliComponents.logger, `\nContent successfully signed.`, '');
+                logger.info(`Address: ${value.address}`);
+                logger.info(`Signature: ${value.signature}`);
+                logger.info(`Network: ${(0, schemas_1.getChainName)(value.chainId)}`);
+                resolve(value);
+            }
+        });
+        return program;
+    });
+}
+exports.runLinkerApp = runLinkerApp;
+async function browse({ logger }, url, params) {
+    logger.info('You need to sign the content before the deployment:');
+    setTimeout(async () => {
+        try {
+            await (0, open_1.default)(`${url}?${params}`);
+        }
+        catch (e) {
+            logger.error(`Unable to open browser automatically`);
+        }
+    }, 5000);
+    logger.info(`Signing app ready at ${url}`);
+}
+async function getCredentials({ fs }) {
+    const privateKey = await fs.readFile((0, path_1.resolve)(__dirname, '../../../certs/localhost.key'), 'utf-8');
+    const certificate = await fs.readFile((0, path_1.resolve)(__dirname, '../../../certs/localhost.crt'), 'utf-8');
+    return { key: privateKey, cert: certificate };
+}
+async function getSceneInfo(scene, rootCID, skipValidations) {
+    const { LANDRegistry, EstateRegistry } = (0, dcl_info_1.getCustomConfig)();
+    const { scene: { parcels, base }, display } = scene;
+    return {
+        baseParcel: base,
+        parcels,
+        rootCID,
+        landRegistry: LANDRegistry,
+        estateRegistry: EstateRegistry,
+        debug: !!process.env.DEBUG,
+        title: display?.title,
+        description: display?.description,
+        skipValidations
+    };
+}

package/dist/commands/deploy/linker-dapp/catalyst-pointers.d.ts

@@ -0,0 +1,20 @@
+import { Entity } from '@dcl/schemas';
+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({ fetch }: Pick<CliComponents, 'fetch'>, 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'>, pointer: string, network?: Network): Promise<CatalystInfo[]>;
+export {};

package/dist/commands/deploy/linker-dapp/catalyst-pointers.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPointers = exports.fetchEntityByPointer = exports.daoCatalysts = void 0;
+async function daoCatalysts({ fetch }, network = 'mainnet') {
+    const tld = network === 'mainnet' ? 'org' : 'zone';
+    const resp = await (await fetch.fetch(`https://peer.decentraland.${tld}/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 fetch.fetch(activeEntities, {
+        method: 'post',
+        headers: { 'content-type': 'application/json', connection: 'close' },
+        body: JSON.stringify({ pointers })
+    });
+    const deployments = response.ok ? (await response.json()) : [];
+    return {
+        baseUrl,
+        deployments
+    };
+}
+exports.fetchEntityByPointer = fetchEntityByPointer;
+async function getPointers(components, pointer, network = 'mainnet') {
+    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) {
+            console.log('Error fetching catalyst pointers', err);
+        }
+    }
+    return catalystInfo;
+}
+exports.getPointers = getPointers;

package/dist/commands/deploy/linker-dapp/routes.d.ts

@@ -0,0 +1,8 @@
+import { Router } from '@well-known-components/http-server';
+import { CliComponents } from '../../../components';
+import { IFile } from '../../../logic/scene-validations';
+import { LinkerResponse, SceneInfo } from './api';
+export declare function setRoutes(components: Pick<CliComponents, 'fs' | 'logger' | 'fetch'>, files: IFile[], sceneInfo: SceneInfo): {
+    router: Router<{}>;
+    futureSignature: import("fp-future").IFuture<LinkerResponse>;
+};

package/dist/commands/deploy/linker-dapp/routes.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setRoutes = void 0;
+const path_1 = require("path");
+const url_1 = __importDefault(require("url"));
+const http_server_1 = require("@well-known-components/http-server");
+const schemas_1 = require("@dcl/schemas");
+const fp_future_1 = __importDefault(require("fp-future"));
+const catalyst_pointers_1 = require("./catalyst-pointers");
+const coordinates_1 = require("../../../logic/coordinates");
+function getContentType(type) {
+    switch (type) {
+        case 'css':
+            return 'text/css';
+        case 'js':
+            return 'application/js';
+        case 'media':
+        default:
+            return 'text/plain';
+    }
+}
+function setRoutes(components, files, sceneInfo) {
+    const futureSignature = (0, fp_future_1.default)();
+    const { fs, logger } = components;
+    const router = new http_server_1.Router();
+    const linkerDapp = (0, path_1.dirname)(require.resolve('@dcl/linker-dapp/package.json'));
+    let deployInfo = {};
+    router.get('/', async () => ({
+        headers: { 'Content-Type': 'text/html' },
+        body: fs.createReadStream((0, path_1.resolve)(linkerDapp, 'index.html'))
+    }));
+    router.get('/static/:type/:path', async (ctx) => {
+        const contentType = getContentType(ctx.params.type);
+        return {
+            headers: { 'Content-Type': contentType },
+            body: fs.createReadStream((0, path_1.resolve)(linkerDapp, 'static', ctx.params.type, ctx.params.path))
+        };
+    });
+    router.get('/manifest.json', async () => ({
+        headers: { 'Content-Type': 'application/json' },
+        body: fs.createReadStream((0, path_1.resolve)(linkerDapp, 'manifest.json'))
+    }));
+    router.get('/api/info', async () => ({
+        body: sceneInfo
+    }));
+    router.get('/api/files', async () => ({
+        body: files.map((file) => ({
+            name: file.path,
+            size: file.size
+        }))
+    }));
+    router.get('/api/catalyst-pointers', async () => {
+        const { x, y } = (0, coordinates_1.getObject)(sceneInfo.baseParcel);
+        const pointer = `${x},${y}`;
+        const chainId = deployInfo.linkerResponse?.chainId || 1;
+        const network = chainId === schemas_1.ChainId.ETHEREUM_MAINNET ? 'mainnet' : 'goerli';
+        const value = await (0, catalyst_pointers_1.getPointers)(components, pointer, network);
+        return {
+            body: {
+                catalysts: value,
+                status: deployInfo.status ?? ''
+            }
+        };
+    });
+    router.get('/api/close', async (ctx) => {
+        const { ok, reason } = url_1.default.parse(ctx.url.toString(), true).query;
+        if (ok === 'true') {
+            const value = JSON.parse(reason?.toString() || '{}');
+            deployInfo = { ...deployInfo, linkerResponse: value };
+            futureSignature.resolve(value);
+            return {};
+        }
+        futureSignature.reject(new Error(`Failed to link: ${reason}`));
+        return {};
+    });
+    router.post('/api/deploy', async (ctx) => {
+        const value = (await ctx.request.json());
+        if (!value.address || !value.signature || !value.chainId) {
+            logger.error(`Invalid payload: ${Object.keys(value).join(' - ')}`);
+            return {};
+        }
+        deployInfo = { ...deployInfo, linkerResponse: value, status: 'deploying' };
+        futureSignature.resolve(value);
+        return {};
+    });
+    return { router, futureSignature };
+}
+exports.setRoutes = setRoutes;

package/dist/commands/export-static/index.js

@@ -115,7 +115,7 @@ async function main(options) {
         (0, beautiful_logs_1.printProgressInfo)(logger, `> ${realmName}/about -> [REALM FILE]`);
     }
     (0, beautiful_logs_1.printSuccess)(logger, `Export finished!`, `=> The entity URN is ${log_1.colors.bold(urn)}`);
-    const sceneJson = await (0, project_files_1.getSceneJson)(options.components, projectRoot);
+    const sceneJson = await (0, scene_validations_1.getValidSceneJson)(options.components, projectRoot);
     const coords = (0, scene_validations_1.getBaseCoords)(sceneJson);
     await options.components.analytics.track('Export static', {
         projectHash: await (0, project_files_1.b64HashingFunction)(projectRoot),

package/dist/commands/start/index.js

@@ -113,14 +113,13 @@ async function main(options) {
     if (watch) {
         await (0, build_1.main)({ ...options, args: { '--dir': projectRoot, '--watch': watch } });
     }
-    await (0, scene_validations_1.validateSceneJson)(options.components, projectRoot);
-    const sceneJson = await (0, project_files_1.getSceneJson)(options.components, projectRoot);
+    const sceneJson = await (0, scene_validations_1.getValidSceneJson)(options.components, projectRoot);
     const baseCoords = (0, scene_validations_1.getBaseCoords)(sceneJson);
     if (await (0, project_validations_1.needsDependencies)(options.components, projectRoot)) {
         const npmModulesPath = path.resolve(projectRoot, 'node_modules');
         throw new error_1.CliError(`Couldn\'t find ${npmModulesPath}, please run: npm install`);
     }
-    const port = options.args['--port'] || (await (0, get_free_port_1.previewPort)());
+    const port = await (0, get_free_port_1.getPort)(options.args['--port']);
     const program = await interfaces_1.Lifecycle.run({
         async initComponents() {
             const metrics = (0, metrics_1.createTestMetricsComponent)(rooms_1.roomsMetrics);

package/dist/logic/account.d.ts

@@ -0,0 +1,6 @@
+export interface Wallet {
+    address: string;
+    privateKey: string;
+    publicKey: string;
+}
+export declare function createWallet(privateKey: string): Wallet;

package/dist/logic/account.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWallet = void 0;
+const eth_connect_1 = require("eth-connect");
+const crypto_1 = require("@dcl/crypto/dist/crypto");
+const error_1 = require("./error");
+function createWallet(privateKey) {
+    let length = 64;
+    if (privateKey.startsWith('0x')) {
+        length = 66;
+    }
+    if (privateKey.length !== length) {
+        throw new error_1.CliError('Addresses should be 64 characters length.');
+    }
+    const pk = (0, eth_connect_1.hexToBytes)(privateKey);
+    const msg = Math.random().toString();
+    const signature = (0, crypto_1.ethSign)(pk, msg);
+    const address = (0, crypto_1.recoverAddressFromEthSignature)(signature, msg);
+    return { address, privateKey, publicKey: '0x' };
+}
+exports.createWallet = createWallet;

package/dist/logic/dcl-info.d.ts

@@ -0,0 +1,26 @@
+import { CliComponents } from '../components';
+/**
+ * Filter undefined keys from provided object
+ */
+export declare function removeEmptyKeys(obj: Record<string, unknown>): Record<string, unknown>;
+export type DCLInfo = {
+    fileExists?: boolean;
+    userId: string;
+    trackStats: boolean;
+    provider?: string;
+    MANAToken?: string;
+    LANDRegistry?: string;
+    EstateRegistry?: string;
+    catalystUrl?: string;
+    dclApiUrl?: string;
+    segmentKey?: string;
+};
+/**
+ * Reads `.dclinfo` file and loads it in-memory to be sync-obtained with `getDCLInfo()` function
+ */
+export declare function loadConfig(components: CliComponents): Promise<DCLInfo>;
+/**
+ * Returns the contents of the `.dclinfo` file. It needs to be loaded first with `loadConfig()` function
+ */
+export declare function getDCLInfo(): DCLInfo;
+export declare function getCustomConfig(): Partial<DCLInfo>;

package/dist/logic/dcl-info.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustomConfig = exports.getDCLInfo = exports.loadConfig = exports.removeEmptyKeys = void 0;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+/**
+ * Filter undefined keys from provided object
+ */
+function removeEmptyKeys(obj) {
+    const result = {};
+    Object.keys(obj)
+        .filter((k) => !!obj[k])
+        .forEach((k) => (result[k] = obj[k]));
+    return result;
+}
+exports.removeEmptyKeys = removeEmptyKeys;
+let config;
+/**
+ * Returns the path to the `.dclinfo` file located in the local HOME folder
+ */
+function getDCLInfoPath() {
+    return path_1.default.resolve(os_1.default.homedir(), '.dclinfo');
+}
+/**
+ * Reads the contents of the `.dclinfo` file
+ */
+async function readDCLInfo({ fs }) {
+    const filePath = getDCLInfoPath();
+    try {
+        const file = await fs.readFile(filePath, 'utf-8');
+        return JSON.parse(file);
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Reads `.dclinfo` file and loads it in-memory to be sync-obtained with `getDCLInfo()` function
+ */
+async function loadConfig(components) {
+    config = (await readDCLInfo(components));
+    return config;
+}
+exports.loadConfig = loadConfig;
+/**
+ * Returns the contents of the `.dclinfo` file. It needs to be loaded first with `loadConfig()` function
+ */
+function getDCLInfo() {
+    return config;
+}
+exports.getDCLInfo = getDCLInfo;
+function getCustomConfig() {
+    const envConfig = getEnvConfig();
+    const dclInfoConfig = getDclInfoConfig();
+    return { ...dclInfoConfig, ...envConfig };
+}
+exports.getCustomConfig = getCustomConfig;
+function getDclInfoConfig() {
+    const dclInfo = getDCLInfo();
+    const fileExists = !!dclInfo;
+    if (!fileExists) {
+        return { fileExists };
+    }
+    const dclInfoConfig = {
+        fileExists,
+        userId: dclInfo.userId,
+        trackStats: !!dclInfo.trackStats,
+        MANAToken: dclInfo.MANAToken,
+        LANDRegistry: dclInfo.LANDRegistry,
+        EstateRegistry: dclInfo.EstateRegistry,
+        catalystUrl: dclInfo.catalystUrl,
+        segmentKey: dclInfo.segmentKey
+    };
+    return removeEmptyKeys(dclInfoConfig);
+}
+function getEnvConfig() {
+    const { RPC_URL, MANA_TOKEN, LAND_REGISTRY, ESTATE_REGISTRY, CONTENT_URL, SEGMENT_KEY } = process.env;
+    const envConfig = {
+        provider: RPC_URL,
+        MANAToken: MANA_TOKEN,
+        LANDRegistry: LAND_REGISTRY,
+        EstateRegistry: ESTATE_REGISTRY,
+        contentUrl: CONTENT_URL,
+        segmentKey: SEGMENT_KEY
+    };
+    return removeEmptyKeys(envConfig);
+}

package/dist/logic/get-free-port.d.ts

@@ -1 +1 @@
-export declare function previewPort(): Promise<number>;
+export declare function getPort(port?: number, failoverPort?: number): Promise<number>;

package/dist/logic/get-free-port.js

@@ -3,18 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.previewPort = void 0;
+exports.getPort = void 0;
 const portfinder_1 = __importDefault(require("portfinder"));
-async function previewPort() {
-    let resolvedPort = 0;
+async function getPort(port = 0, failoverPort = 2044) {
+    let resolvedPort = port && Number.isInteger(port) ? port : 0;
     if (!resolvedPort) {
         try {
-            resolvedPort = await portfinder_1.default.getPortPromise();
+            resolvedPort = await portfinder_1.default.getPortPromise({ port: resolvedPort });
         }
         catch (e) {
-            resolvedPort = 2044;
+            resolvedPort = failoverPort;
         }
     }
     return resolvedPort;
 }
-exports.previewPort = previewPort;
+exports.getPort = getPort;

package/dist/logic/project-files.d.ts

@@ -1,6 +1,5 @@
 import { ContentMapping } from '@dcl/schemas/dist/misc/content-mapping';
 import { CliComponents } from '../components';
-import { Scene } from '@dcl/schemas';
 /**
  * Returns an array of the publishable files for a given folder.
  *
@@ -17,5 +16,4 @@ export declare function normalizeDecentralandFilename(filename: string): string;
  * Returns the content mappings for a specific project folder.
  */
 export declare function getProjectContentMappings(components: Pick<CliComponents, 'fs'>, projectRoot: string, hashingFunction: (filePath: string) => Promise<string>): Promise<ContentMapping[]>;
-export declare function getSceneJson(components: Pick<CliComponents, 'fs'>, projectRoot: string): Promise<Scene>;
 export declare const b64HashingFunction: (str: string) => Promise<string>;

package/dist/logic/project-files.js

@@ -3,13 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.b64HashingFunction = exports.getSceneJson = exports.getProjectContentMappings = exports.normalizeDecentralandFilename = exports.getPublishableFiles = void 0;
+exports.b64HashingFunction = exports.getProjectContentMappings = exports.normalizeDecentralandFilename = exports.getPublishableFiles = void 0;
 const dcl_ignore_1 = require("./dcl-ignore");
 const glob_1 = require("glob");
 const ignore_1 = __importDefault(require("ignore"));
 const path_1 = __importDefault(require("path"));
 const error_1 = require("./error");
-const scene_validations_1 = require("./scene-validations");
 /**
  * Returns an array of the publishable files for a given folder.
  *
@@ -60,6 +59,7 @@ hashingFunction) {
         if (usedFilenames.has(normalizedFile)) {
             throw new error_1.CliError(`DuplicatedFilenameError: the file ${file} exists with a different casing. Please manually remove one occurrence`);
         }
+        usedFilenames.add(normalizedFile);
         ret.push({
             file: normalizedFile,
             hash: await hashingFunction(absolutePath)
@@ -68,11 +68,5 @@ hashingFunction) {
     return ret;
 }
 exports.getProjectContentMappings = getProjectContentMappings;
-async function getSceneJson(components, projectRoot) {
-    const sceneJsonContent = await components.fs.readFile((0, scene_validations_1.getSceneFilePath)(projectRoot), 'utf8');
-    const sceneJson = JSON.parse(sceneJsonContent);
-    return sceneJson;
-}
-exports.getSceneJson = getSceneJson;
 const b64HashingFunction = async (str) => 'b64-' + Buffer.from(str).toString('base64');
 exports.b64HashingFunction = b64HashingFunction;

package/dist/logic/project-validations.js

@@ -16,7 +16,7 @@ async function assertValidProjectFolder(components, projectRoot) {
     switch (true) {
         // case wearable
         case await components.fs.fileExists((0, path_1.resolve)(projectRoot, 'scene.json')): {
-            return { scene: await (0, scene_validations_1.validateSceneJson)(components, projectRoot) };
+            return { scene: await (0, scene_validations_1.getValidSceneJson)(components, projectRoot) };
         }
         default: {
             throw new error_1.CliError(`UnknownProjectKind: the kind of project of the folder ${projectRoot} cannot be identified`);

package/dist/logic/scene-validations.d.ts

@@ -1,17 +1,32 @@
+/// <reference types="node" />
 import { Scene } from '@dcl/schemas';
 import { CliComponents } from '../components';
+export interface IFile {
+    path: string;
+    content: Buffer;
+    size: number;
+}
 export declare const SCENE_FILE = "scene.json";
+export declare const MAX_FILE_SIZE_BYTES: number;
 /**
  * Composes the path to the `scene.json` file based on the provided path.
  * @param projectRoot The path to the directory containing the scene file.
  */
 export declare function getSceneFilePath(projectRoot: string): string;
-export declare function assertValidScene(scene: Scene): Scene;
+export declare function assertValidScene(scene: Scene): void;
 /**
- * Fails the execution if one of the parcel data is invalid
+ * Get valid Scene JSON
  */
-export declare function validateSceneJson(components: Pick<CliComponents, 'fs' | 'logger'>, projectRoot: string): Promise<Scene>;
+export declare function getValidSceneJson(components: Pick<CliComponents, 'fs' | 'logger'>, projectRoot: string): Promise<Scene>;
 export declare function getBaseCoords(scene: Scene): {
     x: number;
     y: number;
 };
+/**
+ * Returns a promise of an array of objects containing the path and the content for all the files in the project.
+ * All the paths added to the `.dclignore` file will be excluded from the results.
+ * Windows directory separators are replaced for POSIX separators.
+ * @param ignoreFile The contents of the .dclignore file
+ */
+export declare function getFiles(components: Pick<CliComponents, 'fs' | 'logger'>, dir: string): Promise<IFile[]>;
+export declare function validateFilesSizes(files: IFile[]): void;

package/dist/logic/scene-validations.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBaseCoords = exports.validateSceneJson = exports.assertValidScene = exports.getSceneFilePath = exports.SCENE_FILE = void 0;
+exports.validateFilesSizes = exports.getFiles = exports.getBaseCoords = exports.getValidSceneJson = exports.assertValidScene = exports.getSceneFilePath = exports.MAX_FILE_SIZE_BYTES = exports.SCENE_FILE = void 0;
 const path_1 = require("path");
 const schemas_1 = require("@dcl/schemas");
 const error_1 = require("./error");
 const coordinates_1 = require("./coordinates");
 const project_files_1 = require("./project-files");
 exports.SCENE_FILE = 'scene.json';
+exports.MAX_FILE_SIZE_BYTES = 50 * 1e6; // 50mb
 /**
  * Composes the path to the `scene.json` file based on the provided path.
  * @param projectRoot The path to the directory containing the scene file.
@@ -46,22 +47,23 @@ function assertValidScene(scene) {
     if (!scene.main?.endsWith('.js')) {
         throw new error_1.CliError(`Main scene format file (${scene.main}) is not a supported format`);
     }
-    return scene;
 }
 exports.assertValidScene = assertValidScene;
 /**
- * Fails the execution if one of the parcel data is invalid
+ * Get valid Scene JSON
  */
-async function validateSceneJson(components, projectRoot) {
+async function getValidSceneJson(components, projectRoot) {
     try {
-        const sceneJson = await (0, project_files_1.getSceneJson)(components, projectRoot);
-        return assertValidScene(sceneJson);
+        const sceneJsonRaw = await components.fs.readFile(getSceneFilePath(projectRoot), 'utf8');
+        const sceneJson = JSON.parse(sceneJsonRaw);
+        assertValidScene(sceneJson);
+        return sceneJson;
     }
     catch (err) {
         throw new error_1.CliError(`Error reading the scene.json file: ${err.message}`);
     }
 }
-exports.validateSceneJson = validateSceneJson;
+exports.getValidSceneJson = getValidSceneJson;
 function getBaseCoords(scene) {
     const [x, y] = scene.scene.base
         .replace(/\ /g, '')
@@ -70,3 +72,34 @@ function getBaseCoords(scene) {
     return { x, y };
 }
 exports.getBaseCoords = getBaseCoords;
+/**
+ * Returns a promise of an array of objects containing the path and the content for all the files in the project.
+ * All the paths added to the `.dclignore` file will be excluded from the results.
+ * Windows directory separators are replaced for POSIX separators.
+ * @param ignoreFile The contents of the .dclignore file
+ */
+async function getFiles(components, dir) {
+    const files = await (0, project_files_1.getPublishableFiles)(components, dir);
+    const data = [];
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const filePath = (0, path_1.resolve)(dir, file);
+        const stat = await components.fs.stat(filePath);
+        const content = await components.fs.readFile(filePath);
+        data.push({
+            path: file.replace(/\\/g, '/'),
+            content: Buffer.from(content),
+            size: stat.size
+        });
+    }
+    return data;
+}
+exports.getFiles = getFiles;
+function validateFilesSizes(files) {
+    for (const { path, size } of files) {
+        if (size > exports.MAX_FILE_SIZE_BYTES) {
+            throw new error_1.CliError(`Maximum file size exceeded: '${path}' is larger than ${exports.MAX_FILE_SIZE_BYTES / 1e6}MB`);
+        }
+    }
+}
+exports.validateFilesSizes = validateFilesSizes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/sdk-commands",
-  "version": "7.0.0-4294380152.commit-0d08b10",
+  "version": "7.0.0-4295573637.commit-6d503ad",
   "description": "",
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -16,8 +16,9 @@
   "author": "Decentraland",
   "license": "Apache-2.0",
   "dependencies": {
-    "@dcl/dcl-rollup": "7.0.6-4294380152.commit-0d08b10",
+    "@dcl/dcl-rollup": "7.0.6-4295573637.commit-6d503ad",
     "@dcl/hashing": "1.1.3",
+    "@dcl/linker-dapp": "0.7.0",
     "@dcl/mini-comms": "1.0.1-20230216163137.commit-a4c75be",
     "@dcl/protocol": "1.0.0-4114477251.commit-ccb88d6",
     "@dcl/schemas": "6.10.0",
@@ -29,6 +30,7 @@
     "arg": "5.0.2",
     "chokidar": "^3.5.3",
     "colorette": "^2.0.19",
+    "dcl-catalyst-client": "^14.0.9",
     "extract-zip": "2.0.1",
     "ignore": "^5.2.4",
     "node-fetch": "^2.6.8",
@@ -52,5 +54,5 @@
   "files": [
     "dist"
   ],
-  "commit": "0d08b10653a3c1b7ccac2fec26b0e3fdf2d6e98b"
+  "commit": "6d503ad455f1a93eca45772ca3ba698f7ad6e089"
 }