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

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupRealmAndComms = void 0;
+const handle_linear_protocol_1 = require("@dcl/mini-comms/dist/logic/handle-linear-protocol");
+const ws_1 = require("@well-known-components/http-server/dist/ws");
+/**
+ * This module handles the BFF mock and communications server for the preview mode.
+ * It runs using @dcl/mini-comms implementing RFC-5
+ */
+function setupRealmAndComms(components, router) {
+    router.get('/about', async (ctx) => {
+        const host = ctx.url.host;
+        const body = {
+            acceptingUsers: true,
+            bff: { healthy: false, publicUrl: host },
+            comms: {
+                healthy: true,
+                protocol: 'v3',
+                fixedAdapter: `ws-room:${ctx.url.protocol.replace(/^http/, 'ws')}//${host}/mini-comms/room-1`
+            },
+            configurations: {
+                networkId: 0,
+                globalScenesUrn: [],
+                scenesUrn: [],
+                realmName: 'LocalPreview'
+            },
+            content: {
+                healthy: true,
+                publicUrl: `${ctx.url.protocol}//${ctx.url.host}/content`
+            },
+            lambdas: {
+                healthy: true,
+                publicUrl: `${ctx.url.protocol}//${ctx.url.host}/lambdas`
+            },
+            healthy: true
+        };
+        return { body };
+    });
+    router.get('/mini-comms/:roomId', async (ctx) => {
+        return (0, ws_1.upgradeWebSocketResponse)((ws) => {
+            if (ws.protocol === 'rfc5' || ws.protocol === 'rfc4') {
+                ws.on('error', (error) => {
+                    console.error(error);
+                    ws.close();
+                });
+                ws.on('close', () => {
+                    console.debug('Websocket closed');
+                });
+                (0, handle_linear_protocol_1.handleSocketLinearProtocol)(components, ws, ctx.params.roomId).catch((err) => {
+                    console.info(err);
+                    ws.close();
+                });
+            }
+        });
+    });
+}
+exports.setupRealmAndComms = setupRealmAndComms;

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

@@ -0,0 +1,2 @@
+import { PreviewComponents } from '../types';
+export declare function wireRouter(components: PreviewComponents, dir: string): Promise<void>;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wireRouter = void 0;
+const realm_1 = require("./realm");
+const http_server_1 = require("@well-known-components/http-server");
+const endpoints_1 = require("./endpoints");
+const ws_1 = require("@well-known-components/http-server/dist/ws");
+async function wireRouter(components, dir) {
+    const router = new http_server_1.Router();
+    const sceneUpdateClients = new Set();
+    router.get('/', async (ctx, next) => {
+        if (ctx.request.headers.get('upgrade') === 'websocket') {
+            return (0, ws_1.upgradeWebSocketResponse)((ws) => initWsConnection(ws, sceneUpdateClients));
+        }
+        return next();
+    });
+    (0, realm_1.setupRealmAndComms)(components, router);
+    (0, endpoints_1.setupEcs6Endpoints)(components, dir, router);
+    components.server.setContext(components);
+    components.server.use(router.allowedMethods());
+    components.server.use(router.middleware());
+}
+exports.wireRouter = wireRouter;
+const initWsConnection = (ws, clients) => {
+    if (ws.readyState === ws.OPEN) {
+        clients.add(ws);
+    }
+    else {
+        ws.on('open', () => clients.add(ws));
+    }
+    ws.on('close', () => clients.delete(ws));
+};

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

@@ -0,0 +1,11 @@
+import { WebSocketServer } from 'ws';
+import { PreviewComponents } from '../types';
+import { IBaseComponent } from '@well-known-components/interfaces';
+export type WebSocketComponent = IBaseComponent & {
+    ws: WebSocketServer;
+};
+/**
+ * Creates a ws-server component
+ * @public
+ */
+export declare function createWsComponent(_: Pick<PreviewComponents, 'logs'>): Promise<WebSocketComponent>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWsComponent = void 0;
+const ws_1 = require("ws");
+/**
+ * Creates a ws-server component
+ * @public
+ */
+async function createWsComponent(_) {
+    const ws = new ws_1.WebSocketServer({ noServer: true });
+    async function stop() {
+        ws.close();
+    }
+    return {
+        stop,
+        ws
+    };
+}
+exports.createWsComponent = createWsComponent;

package/dist/commands/start/types.d.ts

@@ -0,0 +1,18 @@
+import { ILoggerComponent, IMetricsComponent, IHttpServerComponent, IConfigComponent } from '@well-known-components/interfaces';
+import { HTTPProvider } from 'eth-connect';
+import { RoomComponent } from '@dcl/mini-comms/dist/adapters/rooms';
+import { WebSocketComponent } from './server/ws';
+import { CliComponents } from '../../components';
+export type PreviewComponents = CliComponents & {
+    logs: ILoggerComponent;
+    server: IHttpServerComponent<PreviewComponents>;
+    config: IConfigComponent;
+    metrics: IMetricsComponent<any>;
+    ethereumProvider: HTTPProvider;
+    rooms: RoomComponent;
+    ws: WebSocketComponent;
+    signaler: ISignalerComponent;
+};
+export type ISignalerComponent = {
+    programClosed: Promise<void>;
+};

package/dist/commands/start/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/components/eth.d.ts

@@ -0,0 +1,2 @@
+import { HTTPProvider } from 'eth-connect';
+export declare const providerInstance: HTTPProvider;

package/dist/components/eth.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerInstance = void 0;
+const eth_connect_1 = require("eth-connect");
+exports.providerInstance = new eth_connect_1.HTTPProvider('https://rpc.decentraland.org/mainnet?project=sdk-commands');

package/dist/components/fetch.d.ts

@@ -0,0 +1,5 @@
+import * as undici from 'undici';
+export type IFetchComponent = {
+    fetch(url: string, init?: undici.RequestInit): Promise<undici.Response>;
+};
+export declare function createFetchComponent(): IFetchComponent;

package/dist/components/fetch.js

@@ -0,0 +1,33 @@
+"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.createFetchComponent = void 0;
+const undici = __importStar(require("undici"));
+function createFetchComponent() {
+    return {
+        fetch: undici.fetch
+    };
+}
+exports.createFetchComponent = createFetchComponent;

package/dist/components/fs.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as fs from 'fs';
+import * as fsPromises from 'fs/promises';
+/**
+ * @public
+ *
+ * This may be moved to well-known-components in the future
+ */
+export type IFileSystemComponent = Pick<typeof fs, 'createReadStream'> & Pick<typeof fs, 'createWriteStream'> & Pick<typeof fsPromises, 'access' | 'opendir' | 'stat' | 'unlink' | 'mkdir' | 'readFile' | 'writeFile' | 'rename' | 'rmdir'> & {
+    constants: Pick<typeof fs.constants, 'F_OK' | 'R_OK'>;
+} & {
+    fileExists(path: string): Promise<boolean>;
+    directoryExists(path: string): Promise<boolean>;
+    readdir(path: string): Promise<string[]>;
+};
+/**
+ * @public
+ */
+export declare function createFsComponent(): IFileSystemComponent;

package/dist/components/fs.js

@@ -0,0 +1,71 @@
+"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.createFsComponent = void 0;
+const fs = __importStar(require("fs"));
+const fsPromises = __importStar(require("fs/promises"));
+async function fileExists(path) {
+    try {
+        await fs.promises.access(path, fs.constants.F_OK | fs.constants.R_OK);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+async function directoryExists(path) {
+    try {
+        return (await fs.promises.lstat(path)).isDirectory();
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * @public
+ */
+function createFsComponent() {
+    return {
+        createReadStream: fs.createReadStream,
+        createWriteStream: fs.createWriteStream,
+        access: fsPromises.access,
+        writeFile: fsPromises.writeFile,
+        opendir: fsPromises.opendir,
+        stat: fsPromises.stat,
+        unlink: fsPromises.unlink,
+        mkdir: fsPromises.mkdir,
+        rmdir: fsPromises.rmdir,
+        readdir: fsPromises.readdir,
+        readFile: fsPromises.readFile,
+        constants: {
+            F_OK: fs.constants.F_OK,
+            R_OK: fs.constants.R_OK
+        },
+        rename: fsPromises.rename,
+        fileExists,
+        directoryExists
+    };
+}
+exports.createFsComponent = createFsComponent;

package/dist/components/index.d.ts

@@ -0,0 +1,9 @@
+import { ILoggerComponent } from '@well-known-components/interfaces';
+import { IFetchComponent } from './fetch';
+import { IFileSystemComponent } from './fs';
+export type CliComponents = {
+    fs: IFileSystemComponent;
+    fetch: IFetchComponent;
+    logger: ILoggerComponent.ILogger;
+};
+export declare function initComponents(): CliComponents;

package/dist/components/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initComponents = void 0;
+const fetch_1 = require("./fetch");
+const fs_1 = require("./fs");
+const log_1 = require("./log");
+function initComponents() {
+    return {
+        fs: (0, fs_1.createFsComponent)(),
+        fetch: (0, fetch_1.createFetchComponent)(),
+        logger: (0, log_1.createStdoutCliLogger)()
+    };
+}
+exports.initComponents = initComponents;

package/dist/components/log.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="colorette" />
+import { ILoggerComponent } from '@well-known-components/interfaces';
+export declare const colors: import("colorette").Colorette;
+export declare function createStdoutCliLogger(): ILoggerComponent.ILogger;

package/dist/components/log.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStdoutCliLogger = exports.colors = void 0;
+const colorette_1 = require("colorette");
+const error_1 = require("../logic/error");
+/**
+ * This file imitates "cargo" logs. The words are aligned with the colon like this:
+ *        V
+ *   Error: some text provided as argumen
+ *    Info: some text provided as argumen
+ * Success: some text provided as argumen
+ * Warning: some text provided as argumen
+ *        ^
+ */
+const stderr = (...parameters) => {
+    process.stderr.write(`${parameters.filter(($) => $ !== undefined).join('')}\n`);
+};
+// @see https://no-color.org
+// @see https://www.npmjs.com/package/chalk
+exports.colors = (0, colorette_1.createColors)({
+    useColor: process.env.FORCE_COLOR !== '0' && !process.env.NO_COLOR
+});
+function createStdoutCliLogger() {
+    return {
+        log(message, extra) {
+            stderr(message, extra && JSON.stringify(extra));
+        },
+        debug(message, extra) {
+            stderr(exports.colors.blueBright('debug: '), message, extra && JSON.stringify(extra));
+        },
+        error(error, extra) {
+            stderr(exports.colors.redBright('error: '), error, extra && JSON.stringify(extra));
+            /* istanbul ignore next */
+            if (!(error instanceof error_1.CliError) || process.env.DEBUG) {
+                // print the stacktrace if it is not a CliError
+                console.error(error);
+            }
+        },
+        info(message, extra) {
+            stderr(exports.colors.blueBright('info: '), message, extra && JSON.stringify(extra));
+        },
+        warn(message, extra) {
+            stderr(exports.colors.yellow('warning: '), message, extra && JSON.stringify(extra));
+        }
+    };
+}
+exports.createStdoutCliLogger = createStdoutCliLogger;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { getArgs } from './logic/args';
+import { CliComponents } from './components';
+export interface Options {
+    args: ReturnType<typeof getArgs>;
+    components: CliComponents;
+}

package/dist/index.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+"use strict";
+/* istanbul ignore file */
+Object.defineProperty(exports, "__esModule", { value: true });
+const args_1 = require("./logic/args");
+const error_1 = require("./logic/error");
+const commands_1 = require("./logic/commands");
+const components_1 = require("./components");
+const beautiful_logs_1 = require("./logic/beautiful-logs");
+const log_1 = require("./components/log");
+const listCommandsStr = (commands) => commands.map(($) => `\t *sdk-commands ${$} \n`).join('');
+const commandFnsAreValid = (fns) => {
+    const { help, main } = fns;
+    if (!help || !main) {
+        throw new error_1.CliError(`Command does not follow implementation rules:
+      * Requires a "help" function
+      * Requires a "main" function
+    `);
+    }
+    return true;
+};
+async function main() {
+    const helpMessage = (commands) => `Here is the list of commands:\n${listCommandsStr(commands)}`;
+    const args = (0, args_1.getArgs)();
+    const command = process.argv[2];
+    const needsHelp = args['--help'];
+    const components = (0, components_1.initComponents)();
+    const commands = await (0, commands_1.getCommands)(components);
+    if (!commands.includes(command)) {
+        if (needsHelp) {
+            components.logger.info(helpMessage(commands));
+            return;
+        }
+        throw new error_1.CliError(`Command ${command} is invalid. ${helpMessage(commands)}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const cmd = require(`${commands_1.COMMANDS_PATH}/${command}`);
+    if (commandFnsAreValid(cmd)) {
+        const options = { args: cmd.args, components };
+        if (needsHelp) {
+            await cmd.help(options);
+        }
+        else {
+            (0, beautiful_logs_1.printCommand)(components.logger, command);
+            const ret = await cmd.main(options);
+            // print the result of the evaluation as json in the standard output
+            if (cmd.args['--json']) {
+                process.stdout.write(JSON.stringify(ret, null, 2));
+            }
+        }
+    }
+    // rollup watcher leaves many open FSWatcher even in build mode. we must call
+    // process.exit at this point to prevent the program halting forever
+    process.exit(process.exitCode || 0);
+}
+main().catch(function handleError(err) {
+    if (err instanceof error_1.CliError) {
+        console.error(log_1.colors.redBright('Error: ') + err.message);
+    }
+    else {
+        // log with console to show stacktrace and debug information
+        console.error(err);
+        console.warn(`Developer: All errors thrown must be an instance of "CliError"`);
+    }
+    // set an exit code but not finish the program immediately to close any pending work
+    process.exitCode = 1;
+});

package/dist/logic/args.d.ts

@@ -0,0 +1,11 @@
+import { Result } from 'arg';
+export type Args = {
+    [key: string]: string | StringConstructor | NumberConstructor | BooleanConstructor;
+};
+export declare const DEFAULT_ARGS: {
+    '--help': BooleanConstructor;
+    '--json': BooleanConstructor;
+    '-h': string;
+};
+export declare function getArgs(): Result<typeof DEFAULT_ARGS>;
+export declare function getArgs<T extends Args>(args: T): Result<typeof DEFAULT_ARGS & T>;

package/dist/logic/args.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArgs = exports.DEFAULT_ARGS = void 0;
+const arg_1 = __importDefault(require("arg"));
+// updating to TS 4.9 will prevent losing types when
+// enforcing type to be "Args" by using "satisfies Args"
+exports.DEFAULT_ARGS = {
+    '--help': Boolean,
+    '--json': Boolean,
+    '-h': '--help'
+};
+function getArgs(args) {
+    return (0, arg_1.default)({ ...exports.DEFAULT_ARGS, ...args }, { permissive: true });
+}
+exports.getArgs = getArgs;

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

@@ -0,0 +1,5 @@
+import { ILoggerComponent } from '@well-known-components/interfaces';
+export declare function printProgressStep(logger: ILoggerComponent.ILogger, log: string, currentStep: number, maxStep: number): void;
+export declare function printProgressInfo(logger: ILoggerComponent.ILogger, log: string): void;
+export declare function printCommand(logger: ILoggerComponent.ILogger, commandName: string): void;
+export declare function printSuccess(logger: ILoggerComponent.ILogger, operationSuccessfulMessage: string, summary: string): void;

package/dist/logic/beautiful-logs.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printSuccess = exports.printCommand = exports.printProgressInfo = exports.printProgressStep = void 0;
+const log_1 = require("../components/log");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { name, version } = require('../../package.json');
+function printProgressStep(logger, log, currentStep, maxStep) {
+    logger.log(log_1.colors.dim(`[${currentStep}/${maxStep}]`) + ' ' + log);
+}
+exports.printProgressStep = printProgressStep;
+function printProgressInfo(logger, log) {
+    logger.log(log_1.colors.dim(log));
+}
+exports.printProgressInfo = printProgressInfo;
+function printCommand(logger, commandName) {
+    logger.log(log_1.colors.bold(`${name} ${commandName} v${version}`));
+}
+exports.printCommand = printCommand;
+function printSuccess(logger, operationSuccessfulMessage, summary) {
+    // print a space before the success callout
+    logger.log('');
+    logger.log(log_1.colors.greenBright(operationSuccessfulMessage));
+    if (typeof summary === 'string') {
+        logger.log(summary);
+    }
+}
+exports.printSuccess = printSuccess;

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

@@ -0,0 +1,5 @@
+import { Entity } from '@dcl/schemas';
+export declare function fetchEntityByPointer(baseUrl: string, pointers: string[]): Promise<{
+    baseUrl: string;
+    deployments: Entity[];
+}>;

package/dist/logic/catalyst-requests.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchEntityByPointer = void 0;
+const undici_1 = require("undici");
+async function fetchEntityByPointer(baseUrl, pointers) {
+    if (pointers.length === 0)
+        return {
+            baseUrl,
+            deployments: []
+        };
+    const activeEntities = baseUrl + '/content/entities/active';
+    const response = await (0, undici_1.fetch)(activeEntities, {
+        method: 'post',
+        headers: { 'content-type': 'application/json', connection: 'close' },
+        body: JSON.stringify({ pointers })
+    });
+    const deployments = response.ok ? (await response.json()) : [];
+    return {
+        baseUrl,
+        deployments
+    };
+}
+exports.fetchEntityByPointer = fetchEntityByPointer;

package/dist/logic/commands.d.ts

@@ -0,0 +1,3 @@
+import { CliComponents } from '../components';
+export declare const COMMANDS_PATH: string;
+export declare function getCommands({ fs }: Pick<CliComponents, 'fs'>): Promise<string[]>;

package/dist/logic/commands.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommands = exports.COMMANDS_PATH = void 0;
+const path_1 = require("path");
+const error_1 = require("./error");
+exports.COMMANDS_PATH = (0, path_1.resolve)(__dirname, '../commands');
+async function getCommands({ fs }) {
+    const commandDirs = await fs.readdir(exports.COMMANDS_PATH);
+    const commands = commandDirs.map(async (dir) => {
+        const path = (0, path_1.resolve)(exports.COMMANDS_PATH, dir);
+        const statDir = await fs.stat(path);
+        if (!statDir.isDirectory()) {
+            throw new error_1.CliError('Developer: All commands must be inside a folder');
+        }
+        const statIndex = await fs.stat(`${path}/index.js`);
+        if (!statIndex.isFile()) {
+            throw new error_1.CliError('Developer: All commands must have an "index.js" file inside');
+        }
+        return dir;
+    });
+    return Promise.all(commands);
+}
+exports.getCommands = getCommands;

package/dist/logic/coordinates.d.ts

@@ -0,0 +1,37 @@
+export interface IBounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export type Coords = {
+    x: number;
+    y: number;
+};
+/**
+ * Returns metaverse coordinates bounds.
+ * TODO: use functions from @dcl/schemas
+ */
+export declare function getBounds(): IBounds;
+/**
+ * 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
+ */
+export declare function parse(coordinates: string): string[];
+/**
+ * Converts a string-based set of coordinates to an object
+ * @param coords A string containing a set of coordinates
+ */
+export declare function getObject(coords: string): Coords;
+/**
+ * Returns true if the given coordinates are in metaverse bounds
+ */
+export declare function inBounds(x: number, y: number): boolean;
+/**
+ * Returns true if the given parcels array are connected
+ */
+export declare function areConnected(parcels: Coords[]): boolean;
+export declare function isEqual(p1: Coords, p2: Coords): boolean;