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

package/dist/commands/start/index.js

@@ -0,0 +1,217 @@
+"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;
+};
+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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const open_1 = __importDefault(require("open"));
+const fp_future_1 = __importDefault(require("fp-future"));
+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");
+const env_config_provider_1 = require("@well-known-components/env-config-provider");
+const rooms_1 = require("@dcl/mini-comms/dist/adapters/rooms");
+const http_server_1 = require("@well-known-components/http-server");
+const logger_1 = require("@well-known-components/logger");
+const eth_1 = require("../../components/eth");
+const log_1 = require("../../components/log");
+const file_watch_notifier_1 = require("./server/file-watch-notifier");
+const routes_1 = require("./server/routes");
+const ws_1 = require("./server/ws");
+exports.args = (0, args_1.getArgs)({
+    '--dir': String,
+    '--help': Boolean,
+    '--port': Number,
+    '--no-debug': Boolean,
+    '--no-browser': Boolean,
+    '--no-watch': Boolean,
+    '--ci': Boolean,
+    '--skip-install': Boolean,
+    '--web3': Boolean,
+    '-h': '--help',
+    '-p': '--port',
+    '-d': '--no-debug',
+    '-b': '--no-browser',
+    '-w': '--no-watch',
+    '--skip-build': Boolean,
+    '--desktop-client': Boolean
+});
+function help() {
+    return `
+  Usage: sdk-commands start [options]
+
+    Options:
+
+      -h, --help                Displays complete help
+      -p, --port        [port]  Select a custom port for the development server
+      -d, --no-debug            Disable debugging panel
+      -b, --no-browser          Do not open a new browser window
+      -w, --no-watch            Do not open watch for filesystem changes
+      -c, --ci                  Run the parcel previewer on a remote unix server
+      --web3                    Connects preview to browser wallet to use the associated avatar and account
+      --skip-build              Skip build and only serve the files in preview mode
+      --desktop-client          Show URL to launch preview in the desktop client (BETA)
+
+    Examples:
+
+    - Start a local development server for a Decentraland Scene at port 3500
+
+      $ sdk-commands start -p 3500
+
+    - Start a local development server for a Decentraland Scene at a docker container
+
+      $ sdk-commands start --ci
+`;
+}
+exports.help = help;
+async function main(options) {
+    const projectRoot = 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;
+    const skipBuild = exports.args['--skip-build'];
+    const watch = !exports.args['--no-watch'];
+    const enableWeb3 = exports.args['--web3'];
+    const baseCoords = { x: 0, y: 0 };
+    const hasPortableExperience = false;
+    // first run `npm run build`, this can be disabled with --skip-build
+    if (!skipBuild) {
+        await (0, project_validations_1.npmRun)(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 } });
+    }
+    await (0, scene_validations_1.validateSceneJson)(options.components, projectRoot);
+    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 program = await interfaces_1.Lifecycle.run({
+        async initComponents() {
+            const metrics = (0, metrics_1.createTestMetricsComponent)(rooms_1.roomsMetrics);
+            const config = (0, env_config_provider_1.createRecordConfigComponent)({
+                HTTP_SERVER_PORT: port.toString(),
+                HTTP_SERVER_HOST: '0.0.0.0',
+                ...process.env
+            });
+            const logs = await (0, logger_1.createConsoleLogComponent)({});
+            const ws = await (0, ws_1.createWsComponent)({ logs });
+            const server = await (0, http_server_1.createServerComponent)({ config, logs, ws: ws.ws }, {});
+            const rooms = await (0, rooms_1.createRoomsComponent)({
+                metrics,
+                logs,
+                config
+            });
+            const programClosed = (0, fp_future_1.default)();
+            const signaler = {
+                programClosed,
+                async stop() {
+                    // this promise is resolved upon SIGTERM or SIGHUP
+                    // or when program.stop is called
+                    programClosed.resolve();
+                }
+            };
+            return {
+                ...options.components,
+                logger: (0, log_1.createStdoutCliLogger)(),
+                logs,
+                ethereumProvider: eth_1.providerInstance,
+                rooms,
+                config,
+                metrics,
+                server,
+                ws,
+                signaler
+            };
+        },
+        async main({ components, startComponents }) {
+            await (0, routes_1.wireRouter)(components, projectRoot);
+            if (watch) {
+                await (0, file_watch_notifier_1.wireFileWatcherToWebSockets)(components, projectRoot);
+            }
+            await startComponents();
+            const networkInterfaces = os.networkInterfaces();
+            const availableURLs = [];
+            components.logger.log(`Preview server is now running!`);
+            components.logger.log('Available on:\n');
+            Object.keys(networkInterfaces).forEach((dev) => {
+                ;
+                (networkInterfaces[dev] || []).forEach((details) => {
+                    if (details.family === 'IPv4') {
+                        let addr = `http://${details.address}:${port}?position=${baseCoords.x}%2C${baseCoords.y}&ENABLE_ECS7`;
+                        if (debug) {
+                            addr = `${addr}&SCENE_DEBUG_PANEL`;
+                        }
+                        if (enableWeb3 || hasPortableExperience) {
+                            addr = `${addr}&ENABLE_WEB3`;
+                        }
+                        availableURLs.push(addr);
+                    }
+                });
+            });
+            // Push localhost and 127.0.0.1 at top
+            const sortedURLs = availableURLs.sort((a, _b) => {
+                return a.toLowerCase().includes('localhost') || a.includes('127.0.0.1') || a.includes('0.0.0.0') ? -1 : 1;
+            });
+            for (const addr of sortedURLs) {
+                components.logger.log(`    ${addr}`);
+            }
+            if (exports.args['--desktop-client']) {
+                components.logger.log('\n  Desktop client:\n');
+                for (const addr of sortedURLs) {
+                    const searchParams = new URLSearchParams();
+                    searchParams.append('PREVIEW-MODE', addr);
+                    components.logger.log(`    dcl://${searchParams.toString()}&`);
+                }
+            }
+            components.logger.log('\n  Details:\n');
+            components.logger.log('\nPress CTRL+C to exit\n');
+            // Open preferably localhost/127.0.0.1
+            if (openBrowser && sortedURLs.length && !exports.args['--desktop-client']) {
+                try {
+                    await (0, open_1.default)(sortedURLs[0]);
+                }
+                catch (_) {
+                    components.logger.warn('Unable to open browser automatically.');
+                }
+            }
+        }
+    });
+    // this signal is resolved by: (wkc)program.stop(), SIGTERM, SIGHUP
+    // we must wait for it to resolve (when the server stops) to continue with the
+    // program
+    await program.components.signaler.programClosed;
+}
+exports.main = main;

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

@@ -0,0 +1,4 @@
+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>): void;

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

@@ -0,0 +1,399 @@
+"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.setupEcs6Endpoints = void 0;
+const path = __importStar(require("path"));
+const sdk_1 = require("@dcl/schemas/dist/sdk");
+const schemas_1 = require("@dcl/schemas");
+const node_fetch_1 = __importStar(require("node-fetch"));
+const catalyst_requests_1 = require("../../../logic/catalyst-requests");
+const project_files_1 = require("../../../logic/project-files");
+function getCatalystUrl() {
+    return new URL('https://peer.decentraland.org');
+}
+function smartWearableNameToId(name) {
+    return name.toLocaleLowerCase().replace(/ /g, '-');
+}
+function setupEcs6Endpoints(components, dir, router) {
+    const baseFolders = [dir];
+    // 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'))
+        };
+    });
+    router.get('/lambdas/explore/realms', async (ctx) => {
+        return {
+            body: [
+                {
+                    serverName: 'localhost',
+                    url: `http://${ctx.url.host}`,
+                    layer: 'stub',
+                    usersCount: 0,
+                    maxUsers: 100,
+                    userParcels: []
+                }
+            ]
+        };
+    });
+    router.get('/lambdas/contracts/servers', async (ctx) => {
+        return {
+            body: [
+                {
+                    address: `http://${ctx.url.host}`,
+                    owner: '0x0000000000000000000000000000000000000000',
+                    id: '0x0000000000000000000000000000000000000000000000000000000000000000'
+                }
+            ]
+        };
+    });
+    router.get('/lambdas/profiles', async (ctx, next) => {
+        const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`;
+        try {
+            const previewWearables = await getAllPreviewWearables(components, {
+                baseFolders,
+                baseUrl
+            });
+            if (previewWearables.length === 1) {
+                const catalystUrl = getCatalystUrl();
+                const u = new URL(ctx.url.toString());
+                u.host = catalystUrl.host;
+                u.protocol = catalystUrl.protocol;
+                u.port = catalystUrl.port;
+                const req = await (0, node_fetch_1.default)(u.toString(), {
+                    headers: {
+                        connection: 'close'
+                    },
+                    method: ctx.request.method,
+                    body: ctx.request.method === 'get' ? undefined : ctx.request.body
+                });
+                const deployedProfile = (await req.json());
+                if (deployedProfile?.length === 1) {
+                    deployedProfile[0].avatars[0].avatar.wearables.push(...previewWearables.map(($) => $.id));
+                    return {
+                        headers: {
+                            'content-type': req.headers.get('content-type') || 'application/binary'
+                        },
+                        body: deployedProfile
+                    };
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`Failed to catch profile and fill with preview wearables.`, err);
+        }
+        return next();
+    });
+    router.all('/lambdas/:path+', async (ctx) => {
+        const catalystUrl = getCatalystUrl();
+        const u = new URL(ctx.url.toString());
+        u.host = catalystUrl.host;
+        u.protocol = catalystUrl.protocol;
+        u.port = catalystUrl.port;
+        const req = await (0, node_fetch_1.default)(u.toString(), {
+            headers: {
+                connection: 'close'
+            },
+            method: ctx.request.method,
+            body: ctx.request.method === 'get' ? undefined : ctx.request.body
+        });
+        return {
+            headers: {
+                'content-type': req.headers.get('content-type') || 'application/binary'
+            },
+            body: req.body
+        };
+    });
+    router.post('/content/entities', async (ctx) => {
+        const catalystUrl = getCatalystUrl();
+        const headers = new node_fetch_1.Headers();
+        console.log(ctx.request.headers);
+        const res = await (0, node_fetch_1.default)(`${catalystUrl.toString()}/content/entities`, {
+            method: 'post',
+            headers,
+            body: ctx.request.body
+        });
+        return res;
+    });
+    serveStatic(components, dir, router);
+    // TODO: get workspace scenes & wearables...
+    serveFolders(components, router, baseFolders);
+}
+exports.setupEcs6Endpoints = setupEcs6Endpoints;
+function serveFolders(components, router, baseFolders) {
+    router.get('/content/contents/:hash', async (ctx, next) => {
+        if (ctx.params.hash && ctx.params.hash.startsWith('b64-')) {
+            const fullPath = path.resolve(Buffer.from(ctx.params.hash.replace(/^b64-/, ''), 'base64').toString('utf8'));
+            // only return files IF the file is within a baseFolder
+            if (!baseFolders.find((folder) => fullPath.startsWith(folder))) {
+                return next();
+            }
+            return {
+                headers: {
+                    'x-timestamp': Date.now(),
+                    'x-sent': true,
+                    'cache-control': 'no-cache,private,max-age=1'
+                },
+                body: components.fs.createReadStream(fullPath)
+            };
+        }
+        return next();
+    });
+    async function pointerRequestHandler(pointers) {
+        if (!pointers || pointers.length === 0) {
+            return [];
+        }
+        const requestedPointers = new Set(pointers && typeof pointers === 'string' ? [pointers] : pointers);
+        const resultEntities = await getSceneJson(components, baseFolders, Array.from(requestedPointers));
+        const catalystUrl = getCatalystUrl();
+        const remote = (0, catalyst_requests_1.fetchEntityByPointer)(catalystUrl.toString(), pointers.filter(($) => !$.match(/-?\d+,-?\d+/)));
+        const serverEntities = Array.isArray(remote) ? remote : [];
+        return [...resultEntities, ...serverEntities];
+    }
+    // REVIEW RESPONSE FORMAT
+    router.get('/content/entities/scene', async (ctx) => {
+        return {
+            body: await pointerRequestHandler(ctx.url.searchParams.getAll('pointer'))
+        };
+    });
+    // REVIEW RESPONSE FORMAT
+    router.post('/content/entities/active', async (ctx) => {
+        const body = await ctx.request.json();
+        return {
+            body: await pointerRequestHandler(body.pointers)
+        };
+    });
+    router.get('/preview-wearables/:id', async (ctx) => {
+        const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`;
+        const wearables = await getAllPreviewWearables(components, {
+            baseUrl,
+            baseFolders
+        });
+        const wearableId = ctx.params.id;
+        return {
+            body: {
+                ok: true,
+                data: wearables.filter((wearable) => smartWearableNameToId(wearable?.name) === wearableId)
+            }
+        };
+    });
+    router.get('/preview-wearables', async (ctx) => {
+        const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`;
+        return {
+            body: {
+                ok: true,
+                data: await getAllPreviewWearables(components, { baseUrl, baseFolders })
+            }
+        };
+    });
+}
+const b64HashingFunction = async (str) => 'b64-' + Buffer.from(str).toString('base64');
+async function getAllPreviewWearables(components, { baseFolders, baseUrl }) {
+    const wearablePathArray = [];
+    for (const wearableDir of baseFolders) {
+        const wearableJsonPath = path.resolve(wearableDir, 'wearable.json');
+        if (await components.fs.fileExists(wearableJsonPath)) {
+            wearablePathArray.push(wearableJsonPath);
+        }
+    }
+    const ret = [];
+    for (const wearableJsonPath of wearablePathArray) {
+        try {
+            ret.push(await serveWearable(components, wearableJsonPath, baseUrl));
+        }
+        catch (err) {
+            console.error(`Couldn't mock the wearable ${wearableJsonPath}. Please verify the correct format and scheme.`, err);
+        }
+    }
+    return ret;
+}
+async function serveWearable(components, wearableJsonPath, baseUrl) {
+    const wearableDir = path.dirname(wearableJsonPath);
+    const wearableJson = JSON.parse((await components.fs.readFile(wearableJsonPath)).toString());
+    if (!sdk_1.WearableJson.validate(wearableJson)) {
+        const errors = (sdk_1.WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('');
+        console.error(`Unable to validate wearable.json properly, please check it.`, errors);
+        throw new Error(`Invalid wearable.json (${wearableJsonPath})`);
+    }
+    const hashedFiles = await (0, project_files_1.getProjectContentMappings)(components, wearableDir, b64HashingFunction);
+    const thumbnailFiltered = hashedFiles.filter(($) => $?.file === 'thumbnail.png');
+    const thumbnail = thumbnailFiltered.length > 0 && thumbnailFiltered[0]?.hash && `${baseUrl}/${thumbnailFiltered[0].hash}`;
+    const wearableId = 'urn:8dc2d7ad-97e3-44d0-ba89-e8305d795a6a';
+    const representations = wearableJson.data.representations.map((representation) => ({
+        ...representation,
+        mainFile: `male/${representation.mainFile}`,
+        contents: hashedFiles.map(($) => ({
+            key: `male/${$?.file}`,
+            url: `${baseUrl}/${$?.hash}`,
+            hash: $?.hash
+        }))
+    }));
+    return {
+        id: wearableId,
+        rarity: wearableJson.rarity,
+        i18n: [{ code: 'en', text: wearableJson.name }],
+        description: wearableJson.description,
+        thumbnail: thumbnail || '',
+        image: thumbnail || '',
+        collectionAddress: '0x0',
+        baseUrl: `${baseUrl}/`,
+        name: wearableJson.name || '',
+        data: {
+            category: wearableJson.data.category,
+            replaces: [],
+            hides: [],
+            tags: [],
+            representations: representations
+            // scene: hashedFiles as any,
+        }
+    };
+}
+async function getSceneJson(components, projectRoots, pointers) {
+    const requestedPointers = new Set(pointers);
+    const resultEntities = [];
+    const allDeployments = await Promise.all(projectRoots.map(async (projectRoot) => fakeEntityV3FromFolder(components, projectRoot, b64HashingFunction)));
+    for (const pointer of Array.from(requestedPointers)) {
+        // get deployment by pointer
+        const theDeployment = allDeployments.find(($) => $ && $.pointers.includes(pointer));
+        if (theDeployment) {
+            // remove all the required pointers from the requestedPointers set
+            // to prevent sending duplicated entities
+            theDeployment.pointers.forEach(($) => requestedPointers.delete($));
+            // add the deployment to the results
+            resultEntities.push(theDeployment);
+        }
+    }
+    return resultEntities;
+}
+function serveStatic(components, projectRoot, router) {
+    const sdkPath = path.dirname(require.resolve('@dcl/sdk/package.json', {
+        paths: [projectRoot]
+    }));
+    const dclExplorerJsonPath = path.dirname(require.resolve('@dcl/explorer/package.json', {
+        paths: [projectRoot, sdkPath]
+    }));
+    const dclKernelDefaultProfilePath = path.resolve(dclExplorerJsonPath, 'default-profile');
+    const dclKernelImagesDecentralandConnect = path.resolve(dclExplorerJsonPath, 'images', 'decentraland-connect');
+    const routes = [
+        {
+            route: '/',
+            path: path.resolve(dclExplorerJsonPath, 'preview.html'),
+            type: 'text/html'
+        },
+        {
+            route: '/favicon.ico',
+            path: path.resolve(dclExplorerJsonPath, 'favicon.ico'),
+            type: 'text/html'
+        },
+        {
+            route: '/@/explorer/index.js',
+            path: path.resolve(dclExplorerJsonPath, 'index.js'),
+            type: 'text/javascript'
+        }
+    ];
+    for (const route of routes) {
+        router.get(route.route, async (_ctx) => {
+            return {
+                headers: { 'Content-Type': route.type },
+                body: components.fs.createReadStream(route.path)
+            };
+        });
+    }
+    function createStaticRoutes(components, route, folder, transform = (str) => str) {
+        router.get(route, async (ctx, next) => {
+            const file = ctx.params.path;
+            const fullPath = path.resolve(folder, transform(file));
+            // only return files IF the file is within a baseFolder
+            if (!(await components.fs.fileExists(fullPath))) {
+                return next();
+            }
+            const headers = {
+                'x-timestamp': Date.now(),
+                'x-sent': true,
+                'cache-control': 'no-cache,private,max-age=1'
+            };
+            if (fullPath.endsWith('.wasm')) {
+                headers['content-type'] = 'application/wasm';
+            }
+            return {
+                headers,
+                body: components.fs.createReadStream(fullPath)
+            };
+        });
+    }
+    createStaticRoutes(components, '/images/decentraland-connect/:path+', dclKernelImagesDecentralandConnect);
+    createStaticRoutes(components, '/default-profile/:path+', dclKernelDefaultProfilePath);
+    createStaticRoutes(components, '/@/explorer/:path+', dclExplorerJsonPath, (filePath) => filePath.replace(/.br+$/, ''));
+    router.get('/feature-flags/:file', async (ctx) => {
+        const res = await (0, node_fetch_1.default)(`https://feature-flags.decentraland.zone/${ctx.params.file}`, {
+            headers: {
+                connection: 'close'
+            }
+        });
+        return {
+            body: await res.arrayBuffer()
+        };
+    });
+}
+async function fakeEntityV3FromFolder(components, projectRoot, hashingFunction) {
+    const sceneJsonPath = path.resolve(projectRoot, 'scene.json');
+    let isParcelScene = true;
+    const wearableJsonPath = path.resolve(projectRoot, 'wearable.json');
+    if (await components.fs.fileExists(wearableJsonPath)) {
+        try {
+            const wearableJson = JSON.parse(await components.fs.readFile(wearableJsonPath, 'utf-8'));
+            if (!sdk_1.WearableJson.validate(wearableJson)) {
+                const errors = (sdk_1.WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('');
+                console.error(`Unable to validate wearable.json properly, please check it.`, errors);
+                console.error(`Invalid wearable.json (${wearableJsonPath})`);
+            }
+            else {
+                isParcelScene = false;
+            }
+        }
+        catch (err) {
+            console.error(`Unable to load wearable.json properly`, err);
+        }
+    }
+    if ((await components.fs.fileExists(sceneJsonPath)) && isParcelScene) {
+        const sceneJson = JSON.parse(await components.fs.readFile(sceneJsonPath, 'utf-8'));
+        const { base, parcels } = sceneJson.scene;
+        const pointers = new Set();
+        pointers.add(base);
+        parcels.forEach(($) => pointers.add($));
+        const mappedFiles = await (0, project_files_1.getProjectContentMappings)(components, projectRoot, hashingFunction);
+        return {
+            version: 'v3',
+            type: schemas_1.EntityType.SCENE,
+            id: await hashingFunction(projectRoot),
+            pointers: Array.from(pointers),
+            timestamp: Date.now(),
+            metadata: sceneJson,
+            content: mappedFiles
+        };
+    }
+    return null;
+}

package/dist/commands/start/server/file-watch-notifier.d.ts

@@ -0,0 +1,8 @@
+import { PreviewComponents } from '../types';
+/**
+ * This function gets file modification events and sends them to all the connected
+ * websockets, it is used to hot-reload assets of the scene.
+ *
+ * IMPORTANT: this is a legacy protocol and needs to be revisited for SDK7
+ */
+export declare function wireFileWatcherToWebSockets(components: Pick<PreviewComponents, 'fs' | 'ws'>, projectRoot: string): Promise<void>;

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

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wireFileWatcherToWebSockets = void 0;
+const schemas_1 = require("@dcl/schemas");
+const path_1 = __importDefault(require("path"));
+const ws_1 = require("ws");
+const chokidar_1 = __importDefault(require("chokidar"));
+const dcl_ignore_1 = require("../../../logic/dcl-ignore");
+/**
+ * This function gets file modification events and sends them to all the connected
+ * websockets, it is used to hot-reload assets of the scene.
+ *
+ * IMPORTANT: this is a legacy protocol and needs to be revisited for SDK7
+ */
+async function wireFileWatcherToWebSockets(components, projectRoot) {
+    const { clients } = components.ws.ws;
+    const ignored = await (0, dcl_ignore_1.getDCLIgnorePatterns)(components, projectRoot);
+    chokidar_1.default
+        .watch(path_1.default.resolve(projectRoot), {
+        ignored,
+        ignoreInitial: false,
+        cwd: projectRoot
+    })
+        .on('all', async (_, _file) => {
+        // TODO: accumulate changes in an array and debounce
+        return updateScene(projectRoot, clients);
+    });
+}
+exports.wireFileWatcherToWebSockets = wireFileWatcherToWebSockets;
+function updateScene(dir, clients) {
+    for (const client of clients) {
+        if (client.readyState === ws_1.WebSocket.OPEN) {
+            const message = {
+                type: schemas_1.sdk.SCENE_UPDATE,
+                payload: { sceneId: 'b64-' + Buffer.from(dir).toString('base64'), sceneType: schemas_1.sdk.ProjectType.SCENE }
+            };
+            client.send(schemas_1.sdk.UPDATE);
+            client.send(JSON.stringify(message));
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import { PreviewComponents } from '../types';
+import { Router } from '@well-known-components/http-server';
+/**
+ * This module handles the BFF mock and communications server for the preview mode.
+ * It runs using @dcl/mini-comms implementing RFC-5
+ */
+export declare function setupRealmAndComms(components: PreviewComponents, router: Router<PreviewComponents>): void;