@dcl/sdk-commands 7.1.4-4619170473.commit-d3a4f9f → 7.1.4-4619276636.commit-e2c17cb

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

@@ -1,4 +1,5 @@
 import { CliComponents } from '../../components';
+import { SceneProject } from '../../logic/project-validations';
 interface Options {
     args: typeof args;
     components: Pick<CliComponents, 'fs' | 'logger' | 'analytics' | 'spawner'>;
@@ -19,4 +20,5 @@ export declare const args: import("arg").Result<{
 }>;
 export declare function help(): string;
 export declare function main(options: Options): Promise<void>;
+export declare function buildScene(options: Options, project: SceneProject): Promise<void>;
 export {};

package/dist/commands/build/index.js

@@ -1,12 +1,17 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.main = exports.help = exports.args = void 0;
-const path_1 = require("path");
+exports.buildScene = exports.main = exports.help = exports.args = void 0;
+const path_1 = __importDefault(require("path"));
 const args_1 = require("../../logic/args");
 const project_validations_1 = require("../../logic/project-validations");
 const scene_validations_1 = require("../../logic/scene-validations");
 const project_files_1 = require("../../logic/project-files");
 const bundle_1 = require("../../logic/bundle");
+const beautiful_logs_1 = require("../../logic/beautiful-logs");
+const workspace_validations_1 = require("../../logic/workspace-validations");
 exports.args = (0, args_1.getArgs)({
     '--watch': Boolean,
     '-w': '--watch',
@@ -34,26 +39,35 @@ function help() {
 }
 exports.help = help;
 async function main(options) {
-    const workingDirectory = (0, path_1.resolve)(process.cwd(), options.args['--dir'] || '.');
-    await (0, project_validations_1.assertValidProjectFolder)(options.components, workingDirectory);
-    const shouldInstallDeps = await (0, project_validations_1.needsDependencies)(options.components, workingDirectory);
+    const workingDirectory = path_1.default.resolve(process.cwd(), options.args['--dir'] || '.');
+    const workspace = await (0, workspace_validations_1.getValidWorkspace)(options.components, workingDirectory);
+    for (const project of workspace.projects) {
+        (0, beautiful_logs_1.printCurrentProjectStarting)(options.components.logger, project, workspace);
+        if (project.kind === 'scene') {
+            await buildScene(options, project);
+        }
+    }
+}
+exports.main = main;
+async function buildScene(options, project) {
+    const shouldInstallDeps = await (0, project_validations_1.needsDependencies)(options.components, project.workingDirectory);
     if (shouldInstallDeps && !options.args['--skip-install']) {
-        await (0, project_validations_1.installDependencies)(options.components, workingDirectory);
+        await (0, project_validations_1.installDependencies)(options.components, project.workingDirectory);
     }
     const watch = !!options.args['--watch'];
     const { sceneJson } = await (0, bundle_1.bundleProject)(options.components, {
-        workingDirectory,
+        workingDirectory: project.workingDirectory,
         watch,
         single: options.args['--single'],
         production: !!options.args['--production'],
         emitDeclaration: !!options.args['--emitDeclaration']
-    });
+    }, project.scene);
     const coords = (0, scene_validations_1.getBaseCoords)(sceneJson);
     options.components.analytics.track('Build scene', {
-        projectHash: await (0, project_files_1.b64HashingFunction)(workingDirectory),
+        projectHash: await (0, project_files_1.b64HashingFunction)(project.workingDirectory),
         coords,
         isWorkspace: false,
         args: (0, args_1.getArgsUsed)(options.args)
     });
 }
-exports.main = main;
+exports.buildScene = buildScene;

package/dist/commands/export-static/index.d.ts

@@ -1,4 +1,5 @@
 import { CliComponents } from '../../components';
+import { SceneProject } from '../../logic/project-validations';
 interface Options {
     args: typeof args;
     components: Pick<CliComponents, 'fetch' | 'fs' | 'logger' | 'analytics' | 'config'>;
@@ -16,6 +17,10 @@ export declare const args: import("arg").Result<{
 }>;
 export declare function help(): Promise<string>;
 export declare function main(options: Options): Promise<{
+    scenesUrn: string[];
+    destination: string;
+}>;
+export declare function prepareSceneFiles(options: Options, project: SceneProject, outputDirectory: string): Promise<{
     urn: string;
     entityId: string;
     destination: string;

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

@@ -1,10 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.main = exports.help = exports.args = void 0;
-const path_1 = require("path");
+exports.prepareSceneFiles = exports.main = exports.help = exports.args = void 0;
+const path_1 = __importDefault(require("path"));
 const args_1 = require("../../logic/args");
 const hashing_1 = require("@dcl/hashing");
-const project_validations_1 = require("../../logic/project-validations");
 const project_files_1 = require("../../logic/project-files");
 const error_1 = require("../../logic/error");
 const schemas_1 = require("@dcl/schemas");
@@ -12,6 +14,7 @@ const log_1 = require("../../components/log");
 const beautiful_logs_1 = require("../../logic/beautiful-logs");
 const realm_1 = require("../../logic/realm");
 const scene_validations_1 = require("../../logic/scene-validations");
+const workspace_validations_1 = require("../../logic/workspace-validations");
 exports.args = (0, args_1.getArgs)({
     '--dir': String,
     '--destination': String,
@@ -40,11 +43,11 @@ async function help() {
 exports.help = help;
 async function main(options) {
     const { fs, logger } = options.components;
-    const projectRoot = (0, path_1.resolve)(process.cwd(), options.args['--dir'] || '.');
-    const destDirectory = (0, path_1.resolve)(process.cwd(), options.args['--destination'] || '.');
+    const workingDirectory = path_1.default.resolve(process.cwd(), options.args['--dir'] || '.');
+    const outputDirectory = path_1.default.resolve(process.cwd(), options.args['--destination'] || '.');
     const willCreateRealm = !!exports.args['--realmName'];
     let currentStep = 1;
-    const maxSteps = 3 + (willCreateRealm ? 1 : 0);
+    const maxSteps = 1 + (willCreateRealm ? 1 : 0);
     if (willCreateRealm && !exports.args['--baseUrl']) {
         throw new error_1.CliError(`--baseUrl is mandatory when --realmName is provided`);
     }
@@ -52,21 +55,52 @@ async function main(options) {
         throw new error_1.CliError(`--realmName has invalid characters`);
     }
     (0, beautiful_logs_1.printProgressStep)(logger, 'Reading project files...', currentStep++, maxSteps);
-    await fs.mkdir(destDirectory, { recursive: true });
-    if (!(await fs.directoryExists(destDirectory))) {
-        throw new error_1.CliError(`The destination path ${destDirectory} is not a directory`);
+    await fs.mkdir(outputDirectory, { recursive: true });
+    if (!(await fs.directoryExists(outputDirectory))) {
+        throw new error_1.CliError(`The destination path ${outputDirectory} is not a directory`);
     }
-    const project = await (0, project_validations_1.assertValidProjectFolder)(options.components, projectRoot);
-    const filesToExport = await (0, project_files_1.getProjectContentMappings)(options.components, projectRoot, async (file) => {
-        return await (0, hashing_1.hashV1)(fs.createReadStream((0, path_1.resolve)(projectRoot, file)));
+    const scenesUrn = [];
+    const workspace = await (0, workspace_validations_1.getValidWorkspace)(options.components, workingDirectory);
+    for (const project of workspace.projects) {
+        (0, beautiful_logs_1.printCurrentProjectStarting)(options.components.logger, project, workspace);
+        if (project.kind === 'scene') {
+            const result = await prepareSceneFiles(options, project, outputDirectory);
+            scenesUrn.push(result.urn);
+        }
+    }
+    if (willCreateRealm) {
+        // prepare the realm object
+        (0, beautiful_logs_1.printProgressStep)(logger, 'Creating realm file...', currentStep++, maxSteps);
+        const realm = await (0, realm_1.createStaticRealm)(options.components);
+        const realmName = exports.args['--realmName'];
+        realm.configurations.scenesUrn = scenesUrn;
+        realm.configurations.realmName = realmName;
+        // write the realm file
+        const realmDirectory = path_1.default.join(outputDirectory, realmName);
+        await fs.mkdir(realmDirectory, { recursive: true });
+        if (!(await fs.directoryExists(realmDirectory))) {
+            throw new error_1.CliError(`The destination path ${realmDirectory} is not a directory`);
+        }
+        const dst = path_1.default.join(realmDirectory, 'about');
+        await fs.writeFile(dst, JSON.stringify(realm, null, 2));
+        (0, beautiful_logs_1.printProgressInfo)(logger, `> ${realmName}/about -> [REALM FILE]`);
+    }
+    (0, beautiful_logs_1.printSuccess)(logger, `Export finished!`, `=> The entity URN are:${log_1.colors.bold(scenesUrn.map(($) => '\n - ' + $).join(''))}`);
+    return { scenesUrn, destination: outputDirectory };
+}
+exports.main = main;
+async function prepareSceneFiles(options, project, outputDirectory) {
+    const { fs, logger } = options.components;
+    const filesToExport = await (0, project_files_1.getProjectContentMappings)(options.components, project.workingDirectory, async (file) => {
+        return await (0, hashing_1.hashV1)(fs.createReadStream(path_1.default.resolve(project.workingDirectory, file)));
     });
-    (0, beautiful_logs_1.printProgressStep)(logger, 'Copying files...', currentStep++, maxSteps);
+    (0, beautiful_logs_1.printProgressInfo)(logger, 'Copying files...');
     for (const { file, hash } of filesToExport) {
-        const src = (0, path_1.resolve)(projectRoot, file);
-        const dst = (0, path_1.resolve)(destDirectory, hash);
-        if (src.startsWith(destDirectory))
+        const src = path_1.default.resolve(project.workingDirectory, file);
+        const dst = path_1.default.resolve(outputDirectory, hash);
+        if (src.startsWith(outputDirectory))
             continue;
-        (0, beautiful_logs_1.printProgressInfo)(logger, `> ${hash} -> ${file}`);
+        (0, beautiful_logs_1.printProgressInfo)(logger, `> ${hash} -> ${log_1.colors.reset(file)}`);
         if (!(await fs.fileExists(dst))) {
             const content = await fs.readFile(src);
             await fs.writeFile(dst, content);
@@ -83,13 +117,13 @@ async function main(options) {
         metadata: project.scene,
         version: 'v3'
     };
-    (0, beautiful_logs_1.printProgressStep)(logger, 'Generating files...', currentStep++, maxSteps);
+    (0, beautiful_logs_1.printProgressInfo)(logger, 'Generating files...');
     // create the entity file and get the entityId
     const entityRaw = Buffer.from(JSON.stringify(entity), 'utf8');
     const entityId = await (0, hashing_1.hashV1)(entityRaw);
-    const dst = (0, path_1.resolve)(destDirectory, entityId);
+    const dst = path_1.default.resolve(outputDirectory, entityId);
     await fs.writeFile(dst, entityRaw);
-    (0, beautiful_logs_1.printProgressInfo)(logger, `> ${entityId} -> [ENTITY FILE]`);
+    (0, beautiful_logs_1.printProgressInfo)(logger, `> ${entityId} -> ${log_1.colors.reset('[ENTITY FILE]')}`);
     let urn = `urn:decentraland:entity:${entityId}`;
     if (exports.args['--baseUrl']) {
         urn += '?baseUrl=' + exports.args['--baseUrl'];
@@ -97,31 +131,11 @@ async function main(options) {
         if (!urn.endsWith('/'))
             urn += '/';
     }
-    if (willCreateRealm) {
-        // prepare the realm object
-        (0, beautiful_logs_1.printProgressStep)(logger, 'Creating realm file...', currentStep++, maxSteps);
-        const realm = await (0, realm_1.createStaticRealm)(options.components);
-        const realmName = exports.args['--realmName'];
-        realm.configurations.scenesUrn = [urn];
-        realm.configurations.realmName = realmName;
-        // write the realm file
-        const realmDirectory = (0, path_1.resolve)(destDirectory, realmName);
-        await fs.mkdir(realmDirectory, { recursive: true });
-        if (!(await fs.directoryExists(realmDirectory))) {
-            throw new error_1.CliError(`The destination path ${realmDirectory} is not a directory`);
-        }
-        const dst = (0, path_1.resolve)(realmDirectory, 'about');
-        await fs.writeFile(dst, JSON.stringify(realm, null, 2));
-        (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, scene_validations_1.getValidSceneJson)(options.components, projectRoot);
-    const coords = (0, scene_validations_1.getBaseCoords)(sceneJson);
     options.components.analytics.track('Export static', {
-        projectHash: await (0, project_files_1.b64HashingFunction)(projectRoot),
-        coords,
+        projectHash: await (0, project_files_1.b64HashingFunction)(project.workingDirectory),
+        coords: (0, scene_validations_1.getBaseCoords)(project.scene),
         args: (0, args_1.getArgsUsed)(options.args)
     });
-    return { urn, entityId, destination: destDirectory };
+    return { urn, entityId, destination: outputDirectory };
 }
-exports.main = main;
+exports.prepareSceneFiles = prepareSceneFiles;

package/dist/commands/start/index.js

@@ -32,9 +32,7 @@ const path = __importStar(require("path"));
 const open_1 = __importDefault(require("open"));
 const build_1 = require("../build");
 const args_1 = require("../../logic/args");
-const project_validations_1 = require("../../logic/project-validations");
 const scene_validations_1 = require("../../logic/scene-validations");
-const error_1 = require("../../logic/error");
 const get_free_port_1 = require("../../logic/get-free-port");
 const metrics_1 = require("@well-known-components/metrics");
 const interfaces_1 = require("@well-known-components/interfaces");
@@ -50,6 +48,8 @@ const ws_1 = require("./server/ws");
 const project_files_1 = require("../../logic/project-files");
 const rpc_1 = require("./data-layer/rpc");
 const exit_signal_1 = require("../../components/exit-signal");
+const workspace_validations_1 = require("../../logic/workspace-validations");
+const beautiful_logs_1 = require("../../logic/beautiful-logs");
 exports.args = (0, args_1.getArgs)({
     '--dir': String,
     '--help': Boolean,
@@ -98,7 +98,8 @@ async function help() {
 }
 exports.help = help;
 async function main(options) {
-    const projectRoot = path.resolve(process.cwd(), options.args['--dir'] || '.');
+    let baseCoords = { x: 0, y: 0 };
+    const workingDirectory = path.resolve(process.cwd(), options.args['--dir'] || '.');
     const isCi = exports.args['--ci'] || process.env.CI || false;
     const debug = !exports.args['--no-debug'] && !isCi;
     const openBrowser = !exports.args['--no-browser'] && !isCi;
@@ -108,20 +109,30 @@ async function main(options) {
     const enableWeb3 = exports.args['--web3'];
     // TODO: FIX this hardcoded values ?
     const hasPortableExperience = false;
-    // first run `npm run build`, this can be disabled with --skip-build
-    if (!skipBuild) {
-        await (0, project_validations_1.npmRun)(options.components, projectRoot, 'build');
-    }
-    // then start the embedded compiler, this can be disabled with --no-watch
-    if (watch) {
-        await (0, build_1.main)({ ...options, args: { '--dir': projectRoot, '--watch': watch, _: [] } });
-    }
-    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 workspace = await (0, workspace_validations_1.getValidWorkspace)(options.components, workingDirectory);
+    /* istanbul ignore if */
+    if (workspace.projects.length > 1)
+        (0, beautiful_logs_1.printWarning)(options.components.logger, 'Support for multiple projects is still experimental.');
+    for (const project of workspace.projects) {
+        (0, beautiful_logs_1.printCurrentProjectStarting)(options.components.logger, project, workspace);
+        // first run `npm run build`, this can be disabled with --skip-build
+        // then start the embedded compiler, this can be disabled with --no-watch
+        if (watch) {
+            await (0, build_1.buildScene)({ ...options, args: { '--dir': project.workingDirectory, '--watch': true, _: [] } }, project);
+        }
+        else if (!skipBuild) {
+            await (0, build_1.buildScene)({ ...options, args: { '--dir': project.workingDirectory, '--watch': false, _: [] } }, project);
+        }
+        // track the event
+        baseCoords = (0, scene_validations_1.getBaseCoords)(project.scene);
+        options.components.analytics.track('Preview started', {
+            projectHash: await (0, project_files_1.b64HashingFunction)(project.workingDirectory),
+            coords: baseCoords,
+            isWorkspace: false,
+            args: (0, args_1.getArgsUsed)(options.args)
+        });
     }
+    (0, beautiful_logs_1.printProgressInfo)(options.components.logger, 'Starting preview server');
     const port = await (0, get_free_port_1.getPort)(options.args['--port']);
     const program = await interfaces_1.Lifecycle.run({
         async initComponents() {
@@ -156,20 +167,16 @@ async function main(options) {
         async main({ components, startComponents }) {
             // TODO: dataLayerRpc should be an optional component
             const dataLayer = withDataLayer ? await (0, rpc_1.createDataLayer)(components) : undefined;
-            await (0, routes_1.wireRouter)(components, projectRoot, dataLayer);
+            await (0, routes_1.wireRouter)(components, workspace, dataLayer);
             if (watch) {
-                await (0, file_watch_notifier_1.wireFileWatcherToWebSockets)(components, projectRoot);
+                for (const project of workspace.projects) {
+                    await (0, file_watch_notifier_1.wireFileWatcherToWebSockets)(components, project.workingDirectory);
+                }
             }
             await startComponents();
             const networkInterfaces = os.networkInterfaces();
             const availableURLs = [];
-            components.analytics.track('Preview started', {
-                projectHash: await (0, project_files_1.b64HashingFunction)(projectRoot),
-                coords: baseCoords,
-                isWorkspace: false,
-                args: (0, args_1.getArgsUsed)(options.args)
-            });
-            components.logger.log(`Preview server is now running!`);
+            (0, beautiful_logs_1.printProgressInfo)(options.components.logger, 'Preview server is now running!');
             components.logger.log('Available on:\n');
             Object.keys(networkInterfaces).forEach((dev) => {
                 ;

package/dist/commands/start/server/endpoints.d.ts

@@ -1,4 +1,5 @@
 import { Router } from '@well-known-components/http-server';
 import { PreviewComponents } from '../types';
 import { CliComponents } from '../../../components';
-export declare function setupEcs6Endpoints(components: CliComponents, dir: string, router: Router<PreviewComponents>): Promise<void>;
+import { Workspace } from '../../../logic/workspace-validations';
+export declare function setupEcs6Endpoints(components: CliComponents, router: Router<PreviewComponents>, workspace: Workspace): Promise<void>;

package/dist/commands/start/server/endpoints.js

@@ -34,14 +34,14 @@ const config_1 = require("../../../logic/config");
 function smartWearableNameToId(name) {
     return name.toLocaleLowerCase().replace(/ /g, '-');
 }
-async function setupEcs6Endpoints(components, dir, router) {
+async function setupEcs6Endpoints(components, router, workspace) {
     const catalystUrl = new URL(await (0, config_1.getCatalystBaseUrl)(components));
-    const baseFolders = [dir];
+    const baseFolders = workspace.projects.map(($) => $.workingDirectory);
     // handle old preview scene.json
     router.get('/scene.json', async () => {
         return {
             headers: { 'content-type': 'application/json' },
-            body: components.fs.createReadStream(path.join(dir, 'scene.json'))
+            body: components.fs.createReadStream(path.join(baseFolders[0], 'scene.json'))
         };
     });
     router.get('/lambdas/explore/realms', async (ctx) => {
@@ -134,7 +134,7 @@ async function setupEcs6Endpoints(components, dir, router) {
         });
         return res;
     });
-    serveStatic(components, dir, router);
+    serveStatic(components, workspace, router);
     // TODO: get workspace scenes & wearables...
     await serveFolders(components, router, baseFolders);
 }
@@ -283,12 +283,12 @@ async function getSceneJson(components, projectRoots, pointers) {
     }
     return resultEntities;
 }
-function serveStatic(components, projectRoot, router) {
+function serveStatic(components, workspace, router) {
     const sdkPath = path.dirname(require.resolve('@dcl/sdk/package.json', {
-        paths: [projectRoot]
+        paths: [workspace.rootWorkingDirectory, ...workspace.projects.map(($) => $.workingDirectory)]
     }));
     const dclExplorerJsonPath = path.dirname(require.resolve('@dcl/explorer/package.json', {
-        paths: [projectRoot, sdkPath]
+        paths: [workspace.rootWorkingDirectory, ...workspace.projects.map(($) => $.workingDirectory), sdkPath]
     }));
     const dclKernelDefaultProfilePath = path.resolve(dclExplorerJsonPath, 'default-profile');
     const dclKernelImagesDecentralandConnect = path.resolve(dclExplorerJsonPath, 'images', 'decentraland-connect');

package/dist/commands/start/server/file-watch-notifier.js

@@ -30,6 +30,9 @@ async function wireFileWatcherToWebSockets(components, projectRoot) {
     });
 }
 exports.wireFileWatcherToWebSockets = wireFileWatcherToWebSockets;
+/*
+ * IMPORTANT: this is a legacy protocol and needs to be revisited for SDK7
+ */
 function updateScene(dir, clients) {
     for (const client of clients) {
         if (client.readyState === ws_1.WebSocket.OPEN) {

package/dist/commands/start/server/routes.d.ts

@@ -1,3 +1,4 @@
+import { Workspace } from '../../../logic/workspace-validations';
 import { DataLayer } from '../data-layer/rpc';
 import { PreviewComponents } from '../types';
-export declare function wireRouter(components: PreviewComponents, dir: string, dataLayer?: DataLayer): Promise<void>;
+export declare function wireRouter(components: PreviewComponents, workspace: Workspace, dataLayer?: DataLayer): Promise<void>;

package/dist/commands/start/server/routes.js

@@ -6,7 +6,7 @@ const ws_1 = require("@well-known-components/http-server/dist/ws");
 const ws_2 = require("../data-layer/ws");
 const endpoints_1 = require("./endpoints");
 const realm_1 = require("./realm");
-async function wireRouter(components, dir, dataLayer) {
+async function wireRouter(components, workspace, dataLayer) {
     const router = new http_server_1.Router();
     const sceneUpdateClients = new Set();
     if (dataLayer) {
@@ -24,7 +24,7 @@ async function wireRouter(components, dir, dataLayer) {
         return next();
     });
     (0, realm_1.setupRealmAndComms)(components, router);
-    await (0, endpoints_1.setupEcs6Endpoints)(components, dir, router);
+    await (0, endpoints_1.setupEcs6Endpoints)(components, router, workspace);
     components.server.setContext(components);
     components.server.use(router.allowedMethods());
     components.server.use(router.middleware());

package/dist/components/fs.js

@@ -1,4 +1,5 @@
 "use strict";
+/// <reference types="@types/node" />
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/dist/index.js

@@ -62,7 +62,7 @@ main().catch(function handleError(err) {
         // log with console to show stacktrace and debug information
         // eslint-disable-next-line no-console
         console.error(err);
-        (0, log_1.writeToStderr)(`Developer: All errors thrown must be an instance of "CliError"`);
+        (0, log_1.writeToStderr)(`Developer: All errors thrown must be an instance of "CliError"` + err.stack);
     }
     // set an exit code but not finish the program immediately to close any pending work
     process.exit(process.exitCode ?? 1);

package/dist/logic/beautiful-logs.d.ts

@@ -1,5 +1,12 @@
 import { ILoggerComponent } from '@well-known-components/interfaces';
+import { ProjectUnion } from './project-validations';
+import { Workspace } from './workspace-validations';
 export declare function printProgressStep(logger: ILoggerComponent.ILogger, log: string, currentStep: number, maxStep: number): void;
 export declare function printProgressInfo(logger: ILoggerComponent.ILogger, log: string): void;
+/**
+ * If there are more than one project, we print the current project as "progress info"
+ */
+export declare function printCurrentProjectStarting(logger: ILoggerComponent.ILogger, project: ProjectUnion, workspace: Workspace): void;
 export declare function printCommand(logger: ILoggerComponent.ILogger, commandName: string): void;
+export declare function printWarning(logger: ILoggerComponent.ILogger, warning: string): void;
 export declare function printSuccess(logger: ILoggerComponent.ILogger, operationSuccessfulMessage: string, summary: string): void;

package/dist/logic/beautiful-logs.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printSuccess = exports.printCommand = exports.printProgressInfo = exports.printProgressStep = void 0;
+exports.printSuccess = exports.printWarning = exports.printCommand = exports.printCurrentProjectStarting = exports.printProgressInfo = exports.printProgressStep = void 0;
+const path_1 = __importDefault(require("path"));
 const log_1 = require("../components/log");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { name, version } = require('../../package.json');
@@ -12,10 +16,25 @@ function printProgressInfo(logger, log) {
     logger.log(log_1.colors.dim(log));
 }
 exports.printProgressInfo = printProgressInfo;
+/**
+ * If there are more than one project, we print the current project as "progress info"
+ */
+function printCurrentProjectStarting(logger, project, workspace) {
+    if (workspace.projects.length > 1) {
+        const relativePath = path_1.default.relative(workspace.rootWorkingDirectory, project.workingDirectory);
+        const progress = log_1.colors.dim(`[${workspace.projects.indexOf(project) + 1}/${workspace.projects.length}]`);
+        logger.log(log_1.colors.cyan(`in ${relativePath} ${progress}`));
+    }
+}
+exports.printCurrentProjectStarting = printCurrentProjectStarting;
 function printCommand(logger, commandName) {
     logger.log(log_1.colors.bold(`${name} ${commandName} v${version}`));
 }
 exports.printCommand = printCommand;
+function printWarning(logger, warning) {
+    logger.log(log_1.colors.bgBlack(log_1.colors.yellow(log_1.colors.bold(`⚠️ WARNING!`) + ' ' + warning)));
+}
+exports.printWarning = printWarning;
 function printSuccess(logger, operationSuccessfulMessage, summary) {
     // print a space before the success callout
     logger.log('');

package/dist/logic/bundle.d.ts

@@ -1,5 +1,6 @@
 import esbuild from 'esbuild';
 import { CliComponents } from '../components';
+import { Scene } from '@dcl/schemas';
 export type BundleComponents = Pick<CliComponents, 'logger' | 'fs'>;
 export type SceneJson = {
     main: string;
@@ -12,7 +13,7 @@ export type CompileOptions = {
     workingDirectory: string;
     emitDeclaration: boolean;
 };
-export declare function bundleProject(components: BundleComponents, options: CompileOptions): Promise<{
+export declare function bundleProject(components: BundleComponents, options: CompileOptions, sceneJson: Scene): Promise<{
     context: esbuild.BuildContext<{
         entryPoints: string[];
         bundle: true;
@@ -48,5 +49,5 @@ export declare function bundleProject(components: BundleComponents, options: Com
             hashbang: false;
         };
     }>;
-    sceneJson: import("@dcl/schemas").Scene;
+    sceneJson: Scene;
 }>;

package/dist/logic/bundle.js

@@ -11,17 +11,14 @@ 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 glob_1 = require("glob");
-const MAX_STEP = 3;
-async function bundleProject(components, options) {
-    const sceneJson = await (0, scene_validations_1.getValidSceneJson)(components, options.workingDirectory);
+const MAX_STEP = 2;
+async function bundleProject(components, options, sceneJson) {
     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');
     }
@@ -31,12 +28,12 @@ async function bundleProject(components, options) {
     if (!(await components.fs.fileExists(tsconfig))) {
         throw new error_1.CliError(`File ${tsconfig} must exist to compile the Typescript project`);
     }
-    const input = (0, glob_1.globSync)(options.single ?? 'src/index.ts');
+    const input = (0, glob_1.globSync)(options.single ?? 'src/index.ts', { cwd: options.workingDirectory, absolute: true });
     if (!input.length)
         throw new error_1.CliError(`There are no input files to build: ${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.join(','))}`, 2, MAX_STEP);
+    (0, beautiful_logs_1.printProgressStep)(components.logger, `Bundling file ${log_1.colors.bold(input.join(','))}`, 1, MAX_STEP);
     const context = await esbuild_1.default.context({
         entryPoints: input,
         bundle: true,
@@ -105,7 +102,7 @@ function runTypeChecker(components, options) {
     ];
     if (options.watch)
         args.push('--watch');
-    (0, beautiful_logs_1.printProgressStep)(components.logger, `Running type checker`, 3, MAX_STEP);
+    (0, beautiful_logs_1.printProgressStep)(components.logger, `Running type checker`, 2, 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) => {

package/dist/logic/dcl-ignore.js

@@ -28,7 +28,8 @@ exports.defaultDclIgnore = [
 ];
 async function getDCLIgnoreFileContents(components, dir) {
     try {
-        return components.fs.readFile(path_1.default.resolve(dir, '.dclignore'), 'utf8');
+        return await components.fs.readFile(path_1.default.resolve(dir, '.dclignore'), 'utf8');
+        //     ^^^^^ never remove that await.
     }
     catch (e) { }
     return null;

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

@@ -1,14 +1,19 @@
 import { Scene } from '@dcl/schemas';
 import { CliComponents } from '../components';
+export type BaseProject = {
+    workingDirectory: string;
+};
+export type SceneProject = {
+    kind: 'scene';
+    scene: Scene;
+} & BaseProject;
+export type ProjectUnion = SceneProject;
 /**
- * Asserts that the projectRoot is a valid project
+ * Asserts that the workingDirectory 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' | 'spawner'>, directory: string): Promise<void>;
+export declare function assertValidProjectFolder(components: Pick<CliComponents, 'fs' | 'logger'>, workingDirectory: string): Promise<ProjectUnion>;
+export declare function needsDependencies(components: Pick<CliComponents, 'fs'>, workingDirectory: string): Promise<boolean>;
+export declare function installDependencies(components: Pick<CliComponents, 'logger' | 'spawner' | 'fs'>, workingDirectory: string): Promise<void>;
 /**
  * Run NPM commands
  */

package/dist/logic/project-validations.js

@@ -1,24 +1,30 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.npmRun = exports.installDependencies = exports.npm = exports.needsDependencies = exports.assertValidProjectFolder = void 0;
-const path_1 = require("path");
+exports.npmRun = exports.installDependencies = exports.needsDependencies = exports.assertValidProjectFolder = void 0;
+const path_1 = __importDefault(require("path"));
+const log_1 = require("../components/log");
+const beautiful_logs_1 = require("./beautiful-logs");
 const error_1 = require("./error");
 const scene_validations_1 = require("./scene-validations");
 /**
- * Asserts that the projectRoot is a valid project
+ * Asserts that the workingDirectory is a valid project
  */
-async function assertValidProjectFolder(components, projectRoot) {
+async function assertValidProjectFolder(components, workingDirectory) {
     // no validations for now, only check that it exists
-    if (!(await components.fs.fileExists((0, path_1.resolve)(projectRoot, 'package.json'))))
+    if (!(await components.fs.fileExists(path_1.default.resolve(workingDirectory, '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.getValidSceneJson)(components, projectRoot) };
+        // TODO: case wearable
+        // case scene
+        case await components.fs.fileExists((0, scene_validations_1.getSceneFilePath)(workingDirectory)): {
+            return { kind: 'scene', scene: await (0, scene_validations_1.getValidSceneJson)(components, workingDirectory), workingDirectory };
         }
         default: {
-            throw new error_1.CliError(`UnknownProjectKind: the kind of project of the folder ${projectRoot} cannot be identified`);
+            throw new error_1.CliError(`UnknownProjectKind: the kind of project of the folder ${workingDirectory} cannot be identified`);
         }
     }
 }
@@ -26,23 +32,23 @@ 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');
+async function needsDependencies(components, workingDirectory) {
+    const nodeModulesPath = path_1.default.join(workingDirectory, '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';
+const npmBin = /^win/.test(process.platform) ? 'npm.cmd' : 'npm';
 /*
  * Runs "npm install" for desired project
  */
-async function installDependencies(components, directory) {
-    components.logger.info('Installing dependencies...');
+async function installDependencies(components, workingDirectory) {
+    (0, beautiful_logs_1.printProgressInfo)(components.logger, 'Installing dependencies...');
     // TODO: test in windows
-    await components.spawner.exec(directory, exports.npm, ['install']);
-    components.logger.info('Installing dependencies... ✅');
+    await components.spawner.exec(workingDirectory, npmBin, ['install']);
+    (0, beautiful_logs_1.printProgressInfo)(components.logger, log_1.colors.white('✅ Installing dependencies...'));
 }
 exports.installDependencies = installDependencies;
 /**
@@ -50,6 +56,6 @@ exports.installDependencies = installDependencies;
  */
 async function npmRun(components, cwd, command, ...args) {
     // TODO: test in windows
-    await components.spawner.exec(cwd, exports.npm, ['run', command, '--silent', '--', ...args], { env: process.env });
+    await components.spawner.exec(cwd, npmBin, ['run', command, '--silent', '--', ...args], { env: process.env });
 }
 exports.npmRun = npmRun;

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

@@ -0,0 +1,27 @@
+import { JSONSchema, ValidateFunction } from '@dcl/schemas';
+import { CliComponents } from '../components';
+import { ProjectUnion } from './project-validations';
+export type WorkspaceJson = {
+    folders: Array<{
+        path: string;
+    }>;
+};
+export declare namespace WorkspaceJson {
+    const schema: JSONSchema<WorkspaceJson>;
+    const validate: ValidateFunction<WorkspaceJson>;
+}
+export type Workspace = {
+    rootWorkingDirectory: string;
+    projects: Array<ProjectUnion>;
+};
+/**
+ * Composes the path to the `dcl-workspace.json` file based on the provided path.
+ * @param projectRoot The path to the directory containing the file.
+ */
+export declare function getWorkspaceFilePath(projectRoot: string): string;
+export declare function assertValidWorkspace(workspace: WorkspaceJson): void;
+export declare function workspaceFromFolders(components: Pick<CliComponents, 'fs' | 'logger'>, workingDirectory: string, folders: string[]): Promise<Workspace>;
+/**
+ * Returns a workspace by loading the workspace file or generating a single-folder workspace on the fly.
+ */
+export declare function getValidWorkspace(components: Pick<CliComponents, 'fs' | 'logger'>, projectRoot: string): Promise<Workspace>;

package/dist/logic/workspace-validations.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidWorkspace = exports.workspaceFromFolders = exports.assertValidWorkspace = exports.getWorkspaceFilePath = exports.WorkspaceJson = void 0;
+const path_1 = __importStar(require("path"));
+const schemas_1 = require("@dcl/schemas");
+const error_1 = require("./error");
+const project_validations_1 = require("./project-validations");
+var WorkspaceJson;
+(function (WorkspaceJson) {
+    WorkspaceJson.schema = {
+        type: 'object',
+        additionalProperties: true,
+        properties: {
+            folders: {
+                type: 'array',
+                minItems: 1,
+                items: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string'
+                        }
+                    },
+                    required: ['path'],
+                    additionalProperties: true
+                }
+            }
+        },
+        required: ['folders']
+    };
+    WorkspaceJson.validate = (0, schemas_1.generateLazyValidator)(WorkspaceJson.schema);
+})(WorkspaceJson = exports.WorkspaceJson || (exports.WorkspaceJson = {}));
+// this is "overridable" by env var to test integrations like ".code-workspace" instead
+const WORKSPACE_FILE = process.env.WORKSPACE_FILE || 'dcl-workspace.json';
+/**
+ * Composes the path to the `dcl-workspace.json` file based on the provided path.
+ * @param projectRoot The path to the directory containing the file.
+ */
+function getWorkspaceFilePath(projectRoot) {
+    return (0, path_1.resolve)(projectRoot, WORKSPACE_FILE);
+}
+exports.getWorkspaceFilePath = getWorkspaceFilePath;
+/* istanbul ignore next */
+function assertValidWorkspace(workspace) {
+    if (!WorkspaceJson.validate(workspace)) {
+        const errors = [];
+        /* istanbul ignore if */
+        if (WorkspaceJson.validate.errors) {
+            for (const error of WorkspaceJson.validate.errors) {
+                errors.push(`Error validating ${WORKSPACE_FILE}: ${error.message}`);
+            }
+        }
+        /* istanbul ignore next */
+        throw new error_1.CliError(`Invalid ${WORKSPACE_FILE} file:\n${errors.join('\n')}`);
+    }
+}
+exports.assertValidWorkspace = assertValidWorkspace;
+// This function takes a list of folders and returns a workspace containing the projects in the folders.
+// The working directory of each project is the absolute path of the folder.
+// The root working directory of the workspace is the absolute path of the working directory.
+async function workspaceFromFolders(components, workingDirectory, folders) {
+    const ret = {
+        rootWorkingDirectory: workingDirectory,
+        projects: []
+    };
+    for (const folder of folders) {
+        const wd = path_1.default.resolve(workingDirectory, folder);
+        const project = await (0, project_validations_1.assertValidProjectFolder)(components, wd);
+        ret.projects.push(project);
+    }
+    return ret;
+}
+exports.workspaceFromFolders = workspaceFromFolders;
+/**
+ * Returns a workspace by loading the workspace file or generating a single-folder workspace on the fly.
+ */
+async function getValidWorkspace(components, projectRoot) {
+    const workingDirectory = path_1.default.resolve(projectRoot);
+    const workspaceFile = getWorkspaceFilePath(workingDirectory);
+    if (await components.fs.fileExists(workspaceFile)) {
+        // either we load a workspace
+        try {
+            const workspaceJsonRaw = await components.fs.readFile(workspaceFile, 'utf8');
+            const workspaceJson = JSON.parse(workspaceJsonRaw);
+            // assert valid data structure
+            assertValidWorkspace(workspaceJson);
+            return await workspaceFromFolders(components, workingDirectory, workspaceJson.folders.map((f) => f.path));
+        }
+        catch (err) {
+            /* istanbul ignore next */
+            throw new error_1.CliError(`Error reading the ${getWorkspaceFilePath(workingDirectory)} file: ${err.message}`);
+        }
+    }
+    else {
+        // or generate a single-folder workspace on the fly
+        return await workspaceFromFolders(components, workingDirectory, ['.']);
+    }
+}
+exports.getValidWorkspace = getValidWorkspace;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@dcl/sdk-commands",
   "description": "",
-  "version": "7.1.4-4619170473.commit-d3a4f9f",
+  "version": "7.1.4-4619276636.commit-e2c17cb",
   "author": "Decentraland",
   "bin": {
     "sdk-commands": "./dist/index.js"
   },
   "dependencies": {
     "@dcl/hashing": "1.1.3",
-    "@dcl/inspector": "7.1.4-4619170473.commit-d3a4f9f",
+    "@dcl/inspector": "7.1.4-4619276636.commit-e2c17cb",
     "@dcl/linker-dapp": "0.7.0",
     "@dcl/mini-comms": "1.0.1-20230216163137.commit-a4c75be",
     "@dcl/protocol": "1.0.0-4597420155.commit-e877adc",
@@ -60,5 +60,5 @@
     "displayName": "SDK",
     "tsconfig": "./tsconfig.json"
   },
-  "commit": "d3a4f9fa3cc56da6c69ae2b8f52250cc11f4b96a"
+  "commit": "e2c17cba10c6b7e6f69dd012ea03ecc6d245fd01"
 }