@dcl/sdk-commands 7.0.0-4217957637.commit-a393ef7

package/dist/logic/coordinates.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEqual = exports.areConnected = exports.inBounds = exports.getObject = exports.parse = exports.getBounds = void 0;
+/**
+ * Returns metaverse coordinates bounds.
+ * TODO: use functions from @dcl/schemas
+ */
+function getBounds() {
+    return {
+        minX: -150,
+        minY: -150,
+        maxX: 165,
+        maxY: 165
+    };
+}
+exports.getBounds = getBounds;
+/**
+ * Parses a string-based set of coordinates.
+ * - All spaces are removed
+ * - Leading zeroes are removed
+ * - `-0` is converted to `0`
+ * @param coordinates An string containing coordinates in the `x,y; x,y; ...` format
+ */
+function parse(coordinates) {
+    return coordinates.split(';').map((coord) => {
+        const [x, y] = coord.split(',').map(($) => {
+            return parseInt($, 10)
+                .toString() // removes spaces :)
+                .replace('-0', '0')
+                .replace(/undefined|NaN/g, '0');
+        });
+        return `${x},${y}`;
+    });
+}
+exports.parse = parse;
+/**
+ * Converts a string-based set of coordinates to an object
+ * @param coords A string containing a set of coordinates
+ */
+function getObject(coords) {
+    const [x, y] = parse(coords)[0].split(',');
+    return { x: parseInt(x.toString(), 10), y: parseInt(y.toString(), 10) };
+}
+exports.getObject = getObject;
+/**
+ * Returns true if the given coordinates are in metaverse bounds
+ */
+function inBounds(x, y) {
+    const { minX, minY, maxX, maxY } = getBounds();
+    return x >= minX && x <= maxX && y >= minY && y <= maxY;
+}
+exports.inBounds = inBounds;
+/**
+ * Returns true if the given parcels array are connected
+ */
+function areConnected(parcels) {
+    if (parcels.length === 0) {
+        return false;
+    }
+    const visited = visitParcel(parcels[0], parcels);
+    return visited.length === parcels.length;
+}
+exports.areConnected = areConnected;
+function visitParcel(parcel, allParcels, visited = []) {
+    const isVisited = visited.some((visitedParcel) => isEqual(visitedParcel, parcel));
+    if (!isVisited) {
+        visited.push(parcel);
+        const neighbours = getNeighbours(parcel.x, parcel.y, allParcels);
+        neighbours.forEach((neighbours) => visitParcel(neighbours, allParcels, visited));
+    }
+    return visited;
+}
+function getIsNeighbourMatcher(x, y) {
+    return (coords) => (coords.x === x && (coords.y + 1 === y || coords.y - 1 === y)) ||
+        (coords.y === y && (coords.x + 1 === x || coords.x - 1 === x));
+}
+function getNeighbours(x, y, parcels) {
+    return parcels.filter(getIsNeighbourMatcher(x, y));
+}
+function isEqual(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
+}
+exports.isEqual = isEqual;

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

@@ -0,0 +1,8 @@
+import { CliComponents } from '../components';
+export declare const defaultDclIgnore: string[];
+export declare function getDCLIgnoreFileContents(components: Pick<CliComponents, 'fs'>, dir: string): Promise<string | null>;
+/**
+ * Returns the default .dclignore entries plus the ones provided by the user.
+ * In case of .dclignore not existing, it returns a pre-defined list.
+ */
+export declare function getDCLIgnorePatterns(components: Pick<CliComponents, 'fs'>, dir: string): Promise<string[]>;

package/dist/logic/dcl-ignore.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDCLIgnorePatterns = exports.getDCLIgnoreFileContents = exports.defaultDclIgnore = void 0;
+const path_1 = __importDefault(require("path"));
+exports.defaultDclIgnore = [
+    '.*',
+    'package.json',
+    'package-lock.json',
+    'yarn-lock.json',
+    'build.json',
+    'export',
+    'tsconfig.json',
+    'tslint.json',
+    'node_modules',
+    '**/*.ts',
+    '**/*.tsx',
+    'Dockerfile',
+    'dist',
+    'README.md',
+    '*.blend',
+    '*.fbx',
+    '*.zip',
+    '*.rar'
+];
+async function getDCLIgnoreFileContents(components, dir) {
+    try {
+        return components.fs.readFile(path_1.default.resolve(dir, '.dclignore'), 'utf8');
+    }
+    catch (e) { }
+    return null;
+}
+exports.getDCLIgnoreFileContents = getDCLIgnoreFileContents;
+/**
+ * Returns the default .dclignore entries plus the ones provided by the user.
+ * In case of .dclignore not existing, it returns a pre-defined list.
+ */
+async function getDCLIgnorePatterns(components, dir) {
+    const ignoredContent = await getDCLIgnoreFileContents(components, dir);
+    const ignored = (ignoredContent?.split('\n') || exports.defaultDclIgnore).filter(Boolean);
+    ignored.push(...exports.defaultDclIgnore);
+    // by default many files need to be ignored
+    ignored.push('.*', 'node_modules', '**/*.ts', '**/*.tsx');
+    return Array.from(new Set(ignored));
+}
+exports.getDCLIgnorePatterns = getDCLIgnorePatterns;

package/dist/logic/error.d.ts

@@ -0,0 +1,2 @@
+export declare class CliError extends Error {
+}

package/dist/logic/error.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = void 0;
+class CliError extends Error {
+}
+exports.CliError = CliError;

package/dist/logic/exec.d.ts

@@ -0,0 +1,8 @@
+interface Options {
+    env: {
+        [key: string]: string;
+    };
+    silent: boolean;
+}
+export declare function exec(cwd: string, command: string, args: string[], { env, silent }?: Partial<Options>): Promise<void>;
+export {};

package/dist/logic/exec.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exec = void 0;
+const child_process_1 = require("child_process");
+function exec(cwd, command, args, { env, silent } = {}) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            shell: true,
+            cwd,
+            env: { ...process.env, NODE_ENV: '', ...env }
+        });
+        if (!silent) {
+            child.stdout.pipe(process.stdout);
+            child.stderr.pipe(process.stderr);
+        }
+        child.on('close', (code) => {
+            if (code !== 0) {
+                const _ = `${command} ${args.join(' ')}`;
+                reject(new Error(`Command "${_}" exited with code ${code}. Please try running the command manually`));
+                return;
+            }
+            resolve(undefined);
+        });
+    });
+}
+exports.exec = exec;

package/dist/logic/fs.d.ts

@@ -0,0 +1,24 @@
+import { IFileSystemComponent } from '../components/fs';
+import { IFetchComponent } from '../components/fetch';
+/**
+ * Check's if directory is empty
+ * @param dir Directory to check for emptyness
+ */
+export declare function isDirectoryEmpty(components: {
+    fs: IFileSystemComponent;
+}, dir: string): Promise<boolean>;
+/**
+ * Download a file
+ * @param url URL of the file
+ * @param dest Path to where to save the file
+ */
+export declare function download(components: {
+    fs: IFileSystemComponent;
+    fetch: IFetchComponent;
+}, url: string, dest: string): Promise<string>;
+/**
+ * Extracts a .zip file
+ * @param url Path of the zip file
+ * @param dest Path to where to extract the zip file
+ */
+export declare function extract(path: string, dest: string): Promise<string>;

package/dist/logic/fs.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extract = exports.download = exports.isDirectoryEmpty = void 0;
+const extract_zip_1 = __importDefault(require("extract-zip"));
+const path_1 = require("path");
+/**
+ * Check's if directory is empty
+ * @param dir Directory to check for emptyness
+ */
+async function isDirectoryEmpty(components, dir) {
+    const files = await components.fs.readdir(dir);
+    return !files.length;
+}
+exports.isDirectoryEmpty = isDirectoryEmpty;
+/**
+ * Download a file
+ * @param url URL of the file
+ * @param dest Path to where to save the file
+ */
+async function download(components, url, dest) {
+    // we should remove this package and use the native "fetch" when Node
+    // releases it as stable: https://nodejs.org/docs/latest-v18.x/api/globals.html#fetch
+    const data = await (await components.fetch.fetch(url)).arrayBuffer();
+    await components.fs.writeFile(dest, Buffer.from(data));
+    return dest;
+}
+exports.download = download;
+/**
+ * Extracts a .zip file
+ * @param url Path of the zip file
+ * @param dest Path to where to extract the zip file
+ */
+async function extract(path, dest) {
+    const destPath = (0, path_1.resolve)(dest);
+    await (0, extract_zip_1.default)((0, path_1.resolve)(path), { dir: destPath });
+    return destPath;
+}
+exports.extract = extract;

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

@@ -0,0 +1 @@
+export declare function previewPort(): Promise<number>;

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

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

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

@@ -0,0 +1,16 @@
+import { ContentMapping } from '@dcl/schemas/dist/misc/content-mapping';
+import { CliComponents } from '../components';
+/**
+ * Returns an array of the publishable files for a given folder.
+ */
+export declare function getPublishableFiles(components: Pick<CliComponents, 'fs'>, projectRoot: string): Promise<Array<string>>;
+/**
+ * This function converts paths to decentraland-compatible paths.
+ * - From windows separators to unix separators.
+ * - All to lowercase
+ */
+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[]>;

package/dist/logic/project-files.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+/**
+ * Returns an array of the publishable files for a given folder.
+ */
+async function getPublishableFiles(components, projectRoot) {
+    const ignorePatterns = await (0, dcl_ignore_1.getDCLIgnorePatterns)(components, projectRoot);
+    const ig = (0, ignore_1.default)().add(ignorePatterns);
+    const allFiles = (0, glob_1.sync)('**/*', {
+        cwd: projectRoot,
+        absolute: false,
+        dot: false,
+        ignore: ignorePatterns,
+        nodir: true
+    });
+    return ig.filter(allFiles);
+}
+exports.getPublishableFiles = getPublishableFiles;
+/**
+ * This function converts paths to decentraland-compatible paths.
+ * - From windows separators to unix separators.
+ * - All to lowercase
+ */
+function normalizeDecentralandFilename(filename) {
+    return filename.replace(/(\\)/g, '/').toLowerCase();
+}
+exports.normalizeDecentralandFilename = normalizeDecentralandFilename;
+/**
+ * Returns the content mappings for a specific project folder.
+ */
+async function getProjectContentMappings(components, projectRoot, hashingFunction) {
+    const projectFiles = await getPublishableFiles(components, projectRoot);
+    const ret = [];
+    const usedFilenames = new Set();
+    for (const file of projectFiles) {
+        const absolutePath = path_1.default.resolve(projectRoot, file);
+        /* istanbul ignore if */
+        if (!(await components.fs.fileExists(absolutePath)))
+            continue;
+        // remove heading '/'
+        const normalizedFile = normalizeDecentralandFilename(file).replace(/^\/+/, '');
+        /* istanbul ignore if */
+        if (usedFilenames.has(normalizedFile)) {
+            throw new error_1.CliError(`DuplicatedFilenameError: the file ${file} exists with a different casing. Please manually remove one occurrence`);
+        }
+        ret.push({
+            file: normalizedFile,
+            hash: await hashingFunction(absolutePath)
+        });
+    }
+    return ret;
+}
+exports.getProjectContentMappings = getProjectContentMappings;

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

@@ -0,0 +1,15 @@
+import { Scene } from '@dcl/schemas';
+import { CliComponents } from '../components';
+/**
+ * Asserts that the projectRoot is a valid project
+ */
+export declare function assertValidProjectFolder(components: Pick<CliComponents, 'fs' | 'logger'>, projectRoot: string): Promise<{
+    scene: Scene;
+}>;
+export declare function needsDependencies(components: Pick<CliComponents, 'fs'>, dir: string): Promise<boolean>;
+export declare const npm: string;
+export declare function installDependencies(components: Pick<CliComponents, 'logger'>, directory: string): Promise<void>;
+/**
+ * Run NPM commands
+ */
+export declare function npmRun(cwd: string, command: string, ...args: string[]): Promise<void>;

package/dist/logic/project-validations.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.npmRun = exports.installDependencies = exports.npm = exports.needsDependencies = exports.assertValidProjectFolder = void 0;
+const path_1 = require("path");
+const error_1 = require("./error");
+const exec_1 = require("./exec");
+const scene_validations_1 = require("./scene-validations");
+/**
+ * Asserts that the projectRoot is a valid project
+ */
+async function assertValidProjectFolder(components, projectRoot) {
+    // no validations for now, only check that it exists
+    if (!(await components.fs.fileExists((0, path_1.resolve)(projectRoot, 'package.json'))))
+        throw new error_1.CliError(`The project root doesn't have a package.json file`);
+    // now we will iterate over different file to evaluate the project kind
+    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) };
+        }
+        default: {
+            throw new error_1.CliError(`UnknownProjectKind: the kind of project of the folder ${projectRoot} cannot be identified`);
+        }
+    }
+}
+exports.assertValidProjectFolder = assertValidProjectFolder;
+/*
+ * Returns true if the project contains an empty node_modules folder
+ */
+async function needsDependencies(components, dir) {
+    const nodeModulesPath = (0, path_1.resolve)(dir, 'node_modules');
+    const hasNodeModulesFolder = await components.fs.directoryExists(nodeModulesPath);
+    const isNodeModulesEmpty = hasNodeModulesFolder && (await components.fs.readdir(nodeModulesPath)).length === 0;
+    return !hasNodeModulesFolder || isNodeModulesEmpty;
+}
+exports.needsDependencies = needsDependencies;
+/* istanbul ignore next */
+exports.npm = /^win/.test(process.platform) ? 'npm.cmd' : 'npm';
+/*
+ * Runs "npm install" for desired project
+ */
+async function installDependencies(components, directory) {
+    components.logger.info('Installing dependencies...');
+    // TODO: test in windows
+    await (0, exec_1.exec)(directory, exports.npm, ['install']);
+    components.logger.log('Installing dependencies... ✅');
+}
+exports.installDependencies = installDependencies;
+/**
+ * Run NPM commands
+ */
+async function npmRun(cwd, command, ...args) {
+    // TODO: test in windows
+    await (0, exec_1.exec)(cwd, exports.npm, ['run', command, '--silent', '--', ...args], { env: process.env });
+}
+exports.npmRun = npmRun;

package/dist/logic/realm.d.ts

@@ -0,0 +1,2 @@
+import { AboutResponse } from '@dcl/protocol/out-js/decentraland/bff/http_endpoints.gen';
+export declare function createStaticRealm(): AboutResponse;

package/dist/logic/realm.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStaticRealm = void 0;
+function createStaticRealm() {
+    return {
+        acceptingUsers: true,
+        bff: { healthy: false, publicUrl: `https://peer.decentraland.org/bff` },
+        comms: {
+            healthy: true,
+            protocol: 'v3',
+            fixedAdapter: `offline:offline`
+        },
+        configurations: {
+            networkId: 0,
+            globalScenesUrn: [],
+            scenesUrn: [],
+            realmName: 'SdkStaticExport'
+        },
+        content: {
+            healthy: true,
+            publicUrl: `https://peer.decentraland.org/content`
+        },
+        lambdas: {
+            healthy: true,
+            publicUrl: `https://peer.decentraland.org/lambdas`
+        },
+        healthy: true
+    };
+}
+exports.createStaticRealm = createStaticRealm;

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

@@ -0,0 +1,13 @@
+import { Scene } from '@dcl/schemas';
+import { CliComponents } from '../components';
+export declare const SCENE_FILE = "scene.json";
+/**
+ * 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;
+/**
+ * Fails the execution if one of the parcel data is invalid
+ */
+export declare function validateSceneJson(components: Pick<CliComponents, 'fs' | 'logger'>, projectRoot: string): Promise<Scene>;

package/dist/logic/scene-validations.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSceneJson = exports.assertValidScene = exports.getSceneFilePath = 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");
+exports.SCENE_FILE = 'scene.json';
+/**
+ * Composes the path to the `scene.json` file based on the provided path.
+ * @param projectRoot The path to the directory containing the scene file.
+ */
+function getSceneFilePath(projectRoot) {
+    return (0, path_1.resolve)(projectRoot, exports.SCENE_FILE);
+}
+exports.getSceneFilePath = getSceneFilePath;
+function assertValidScene(scene) {
+    if (!schemas_1.Scene.validate(scene)) {
+        const errors = [];
+        if (schemas_1.Scene.validate.errors) {
+            for (const error of schemas_1.Scene.validate.errors) {
+                errors.push(`Error validating scene.json: ${error.message}`);
+            }
+        }
+        throw new error_1.CliError('Invalid scene.json file:\n' + errors.join('\n'));
+    }
+    const parcelSet = new Set(scene.scene?.parcels);
+    if (parcelSet.size < scene.scene?.parcels?.length) {
+        throw new error_1.CliError(`There are duplicated parcels at scene.json.`);
+    }
+    if (!parcelSet.has(scene.scene?.base)) {
+        throw new error_1.CliError(`Your base parcel ${scene.scene?.base} should be included on parcels attribute at scene.json`);
+    }
+    const objParcels = scene.scene?.parcels?.map(coordinates_1.getObject);
+    objParcels.forEach(({ x, y }) => {
+        if ((0, coordinates_1.inBounds)(x, y)) {
+            return;
+        }
+        const { minX, maxX } = (0, coordinates_1.getBounds)();
+        throw new error_1.CliError(`Coordinates ${x},${y} are outside of allowed limits (from ${minX} to ${maxX})`);
+    });
+    if (!(0, coordinates_1.areConnected)(objParcels)) {
+        throw new error_1.CliError('Parcels described on scene.json are not connected. They should be one next to each other');
+    }
+    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
+ */
+async function validateSceneJson(components, projectRoot) {
+    try {
+        const sceneJsonRaw = await components.fs.readFile(getSceneFilePath(projectRoot), 'utf8');
+        const sceneJson = JSON.parse(sceneJsonRaw);
+        return assertValidScene(sceneJson);
+    }
+    catch (err) {
+        throw new error_1.CliError(`Error reading the scene.json file: ${err.message}`);
+    }
+}
+exports.validateSceneJson = validateSceneJson;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@dcl/sdk-commands",
+  "version": "7.0.0-4217957637.commit-a393ef7",
+  "description": "",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "tsc -p tsconfig.json --watch"
+  },
+  "bin": {
+    "sdk-commands": "./dist/index.js"
+  },
+  "keywords": [],
+  "tsdoc": {
+    "tsdocFlavor": "AEDoc"
+  },
+  "author": "Decentraland",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@dcl/dcl-rollup": "7.0.6-4217957637.commit-a393ef7",
+    "@dcl/hashing": "1.1.3",
+    "@dcl/mini-comms": "1.0.1-20230216163137.commit-a4c75be",
+    "@dcl/protocol": "1.0.0-4114477251.commit-ccb88d6",
+    "@dcl/schemas": "6.10.0",
+    "@well-known-components/env-config-provider": "^1.2.0",
+    "@well-known-components/http-server": "^2.0.0-20230216161243.commit-bfe3f0a",
+    "@well-known-components/logger": "^3.1.2",
+    "@well-known-components/metrics": "^2.0.1",
+    "arg": "5.0.2",
+    "chokidar": "^3.5.3",
+    "colorette": "^2.0.19",
+    "extract-zip": "2.0.1",
+    "ignore": "^5.2.4",
+    "node-fetch": "^2.6.8",
+    "open": "^8.4.0",
+    "portfinder": "^1.0.32",
+    "undici": "^5.19.1"
+  },
+  "devDependencies": {
+    "@types/node-fetch": "^2.6.1",
+    "@types/ws": "^8.5.4"
+  },
+  "minCliVersion": "3.14.1",
+  "typedoc": {
+    "entryPoint": "./src/index.ts",
+    "readmeFile": "./README.md",
+    "displayName": "SDK",
+    "tsconfig": "./tsconfig.json"
+  },
+  "commit": "a393ef72d7ad52edf0a4c2f49ad2e22668c7a88d"
+}

package/src/commands/build/index.ts

@@ -0,0 +1,68 @@
+import { resolve } from 'path'
+import { CliComponents } from '../../components'
+import { getArgs } from '../../logic/args'
+import { compile } from '@dcl/dcl-rollup/compile'
+import future from 'fp-future'
+import { assertValidProjectFolder, installDependencies, needsDependencies } from '../../logic/project-validations'
+
+interface Options {
+  args: Omit<typeof args, '_'>
+  components: Pick<CliComponents, 'fs' | 'logger'>
+}
+
+export const args = getArgs({
+  '--watch': Boolean,
+  '-w': '--watch',
+  '--production': Boolean,
+  '-p': '--production',
+  '--skip-install': Boolean,
+  '--dir': String
+})
+
+export function help() {
+  return `
+  Usage: 'sdk-commands build [options]'
+    Options:'
+      -h, --help                Displays complete help
+      -w, --watch               Watch for file changes and build on change
+      -p, --production          Build without sourcemaps
+      --skip-install            Skip installing dependencies
+      --dir                     Path to directory to build
+
+    Example:
+    - Build your scene:
+      '$ sdk-commands build'
+  `
+}
+
+export async function main(options: Options) {
+  const projectRoot = resolve(process.cwd(), options.args['--dir'] || '.')
+
+  await assertValidProjectFolder(options.components, projectRoot)
+
+  const shouldInstallDeps = await needsDependencies(options.components, projectRoot)
+
+  if (shouldInstallDeps && !options.args['--skip-install']) {
+    await installDependencies(options.components, projectRoot)
+  }
+
+  const watch = !!options.args['--watch']
+
+  const watchingFuture = future<any>()
+
+  await compile({
+    project: projectRoot,
+    watch,
+    production: !!options.args['--production'],
+    watchingFuture
+  })
+
+  if (!watch) {
+    watchingFuture.resolve(null)
+  }
+
+  await watchingFuture
+
+  // track stuff...
+  // https://github.com/decentraland/cli/blob/main/src/commands/build.ts
+}