@dcl/sdk-commands 7.0.0-4293371227.commit-54082c6 → 7.0.0-4295573637.commit-6d503ad

package/src/commands/start/server/file-watch-notifier.ts

@@ -1,45 +0,0 @@
-import { sdk } from '@dcl/schemas'
-import path from 'path'
-import { WebSocket } from 'ws'
-import chokidar from 'chokidar'
-import { getDCLIgnorePatterns } from '../../../logic/dcl-ignore'
-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 async function wireFileWatcherToWebSockets(
-  components: Pick<PreviewComponents, 'fs' | 'ws'>,
-  projectRoot: string
-) {
-  const { clients } = components.ws.ws
-  const ignored = await getDCLIgnorePatterns(components, projectRoot)
-
-  chokidar
-    .watch(path.resolve(projectRoot), {
-      ignored,
-      ignoreInitial: false,
-      cwd: projectRoot
-    })
-    .on('all', async (_, _file) => {
-      // TODO: accumulate changes in an array and debounce
-      return updateScene(projectRoot, clients)
-    })
-}
-
-function updateScene(dir: string, clients: Set<WebSocket>): void {
-  for (const client of clients) {
-    if (client.readyState === WebSocket.OPEN) {
-      const message: sdk.SceneUpdate = {
-        type: sdk.SCENE_UPDATE,
-        payload: { sceneId: 'b64-' + Buffer.from(dir).toString('base64'), sceneType: sdk.ProjectType.SCENE }
-      }
-
-      client.send(sdk.UPDATE)
-      client.send(JSON.stringify(message))
-    }
-  }
-}

package/src/commands/start/server/realm.ts

@@ -1,63 +0,0 @@
-import { handleSocketLinearProtocol } from '@dcl/mini-comms/dist/logic/handle-linear-protocol'
-import { PreviewComponents } from '../types'
-import { AboutResponse } from '@dcl/protocol/out-ts/decentraland/bff/http_endpoints.gen'
-import { Router } from '@well-known-components/http-server'
-import { upgradeWebSocketResponse } from '@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
- */
-
-export function setupRealmAndComms(components: PreviewComponents, router: Router<PreviewComponents>) {
-  router.get('/about', async (ctx) => {
-    const host = ctx.url.host
-
-    const body: AboutResponse = {
-      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 upgradeWebSocketResponse((ws: any) => {
-      if (ws.protocol === 'rfc5' || ws.protocol === 'rfc4') {
-        ws.on('error', (error: any) => {
-          console.error(error)
-          ws.close()
-        })
-
-        ws.on('close', () => {
-          console.debug('Websocket closed')
-        })
-
-        handleSocketLinearProtocol(components, ws, ctx.params.roomId).catch((err: any) => {
-          console.info(err)
-          ws.close()
-        })
-      }
-    })
-  })
-}

package/src/commands/start/server/routes.ts

@@ -1,36 +0,0 @@
-import { WebSocket } from 'ws'
-import { setupRealmAndComms } from './realm'
-import { Router } from '@well-known-components/http-server'
-import { setupEcs6Endpoints } from './endpoints'
-import { PreviewComponents } from '../types'
-import { upgradeWebSocketResponse } from '@well-known-components/http-server/dist/ws'
-
-export async function wireRouter(components: PreviewComponents, dir: string) {
-  const router = new Router<PreviewComponents>()
-
-  const sceneUpdateClients = new Set<WebSocket>()
-
-  router.get('/', async (ctx, next) => {
-    if (ctx.request.headers.get('upgrade') === 'websocket') {
-      return upgradeWebSocketResponse((ws) => initWsConnection(ws as any as WebSocket, sceneUpdateClients))
-    }
-
-    return next()
-  })
-
-  setupRealmAndComms(components, router)
-  setupEcs6Endpoints(components, dir, router)
-
-  components.server.setContext(components)
-  components.server.use(router.allowedMethods())
-  components.server.use(router.middleware())
-}
-
-const initWsConnection = (ws: WebSocket, clients: Set<WebSocket>) => {
-  if (ws.readyState === ws.OPEN) {
-    clients.add(ws)
-  } else {
-    ws.on('open', () => clients.add(ws))
-  }
-  ws.on('close', () => clients.delete(ws))
-}

package/src/commands/start/server/ws.ts

@@ -1,24 +0,0 @@
-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 async function createWsComponent(_: Pick<PreviewComponents, 'logs'>): Promise<WebSocketComponent> {
-  const ws = new WebSocketServer({ noServer: true })
-
-  async function stop() {
-    ws.close()
-  }
-
-  return {
-    stop,
-    ws
-  }
-}

package/src/commands/start/types.ts

@@ -1,26 +0,0 @@
-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 resolves when the component is stopped
-  programClosed: Promise<void>
-}

package/src/components/analytics.ts

@@ -1,92 +0,0 @@
-import { v4 as uuidv4 } from 'uuid'
-import { Analytics } from '@segment/analytics-node'
-import future from 'fp-future'
-
-import { CliComponents } from '.'
-import { colors } from './log'
-
-export type IAnalyticsComponent = {
-  get(): Analytics
-  identify(): Promise<void>
-  track<T extends keyof Events>(eventName: T, eventProps: Events[T]): Promise<void>
-}
-
-type Events = {
-  'Scene created': {
-    projectType: string
-    url: string
-  }
-  'Preview started': {
-    projectHash: string
-    coords: { x: number; y: number }
-    isWorkspace: boolean
-  }
-  'Build scene': {
-    projectHash: string
-    coords: { x: number; y: number }
-    isWorkspace: boolean
-  }
-  'Export static': {
-    projectHash: string
-    coords: { x: number; y: number }
-  }
-}
-
-export async function createAnalyticsComponent({
-  dclInfoConfig
-}: Pick<CliComponents, 'dclInfoConfig'>): Promise<IAnalyticsComponent> {
-  const USER_ID = 'sdk-commands-user'
-  const config = await dclInfoConfig.get()
-  const analytics: Analytics = new Analytics({ writeKey: config.segmentKey ?? '' })
-  return {
-    get() {
-      return analytics
-    },
-    async identify() {
-      if (!config.userId) {
-        console.log(
-          `Decentraland CLI sends anonymous usage stats to improve their products, if you want to disable it change the configuration at ${colors.bold(
-            '~/.dclinfo'
-          )}\n`
-        )
-
-        const userId = uuidv4()
-        await dclInfoConfig.updateDCLInfo({ userId, trackStats: true })
-        analytics.identify({
-          userId: USER_ID,
-          traits: {
-            devId: userId,
-            createdAt: new Date()
-          }
-        })
-      }
-    },
-    async track<T extends keyof Events>(eventName: T, eventProps: Events[T]) {
-      const trackFuture = future<void>()
-      const { userId, trackStats } = await dclInfoConfig.get()
-      if (!trackStats) {
-        return trackFuture.resolve()
-      }
-      const trackInfo = {
-        userId: USER_ID,
-        event: eventName,
-        properties: {
-          ...eventProps,
-          os: process.platform,
-          nodeVersion: process.version,
-          cliVersion: await dclInfoConfig.getVersion(),
-          isCI: dclInfoConfig.isCI(),
-          isEditor: dclInfoConfig.isEditor(),
-          devId: userId
-        }
-      }
-      analytics.track(trackInfo, () => {
-        trackFuture.resolve()
-      })
-      if (!dclInfoConfig.isProduction()) {
-        console.log(trackInfo)
-      }
-      return trackFuture
-    }
-  }
-}

package/src/components/dcl-info-config.ts

@@ -1,63 +0,0 @@
-import path, { resolve } from 'path'
-import { CliComponents } from '.'
-import { DCLInfo, getDCLInfoConfig, getDclInfoPath, getEnvConfig } from '../logic/config'
-import { readJSON, writeJSON } from '../logic/fs'
-
-export type IDCLInfoConfigComponent = {
-  get(): Promise<DCLInfo>
-  updateDCLInfo(value: Partial<DCLInfo>): Promise<Partial<DCLInfo>>
-  getVersion(): Promise<string>
-  isCI(): boolean
-  isEditor(): boolean
-  isProduction(): boolean
-}
-
-export async function createDCLInfoConfigComponent({
-  fs
-}: Pick<CliComponents, 'fs'>): Promise<IDCLInfoConfigComponent> {
-  function isProduction() {
-    return process.env.NODE_ENV === 'production' || __filename.includes('node_modules')
-  }
-  const defaultConfig: Partial<DCLInfo> = {
-    userId: '',
-    trackStats: false,
-    segmentKey: isProduction() ? 'sFdziRVDJo0taOnGzTZwafEL9nLIANZ3' : 'mjCV5Dc4VAKXLJAH5g7LyHyW1jrIR3to'
-  }
-
-  return {
-    async get() {
-      const dclInfoConfig = await getDCLInfoConfig({ fs })
-      const envConfig = getEnvConfig()
-      const config = { ...defaultConfig, ...dclInfoConfig, ...envConfig }
-      return config
-    },
-    updateDCLInfo(value: Partial<DCLInfo>) {
-      return writeJSON({ fs }, getDclInfoPath(), value)
-    },
-    async getVersion() {
-      try {
-        /* istanbul ignore next */
-        const sdkPath = path.dirname(
-          require.resolve('@dcl/sdk/package.json', {
-            paths: [process.cwd()]
-          })
-        )
-        /* istanbul ignore next */
-        const packageJson = await readJSON<{ version: string }>({ fs }, resolve(sdkPath, 'package.json'))
-        /* istanbul ignore next */
-        return packageJson.version ?? 'unknown'
-      } catch (e) {
-        return 'unknown'
-      }
-    },
-    isEditor() {
-      return process.env.EDITOR === 'true'
-    },
-    isCI() {
-      return process.env.CI === 'true' || process.argv.includes('--ci') || process.argv.includes('--c')
-    },
-    isProduction() {
-      return isProduction()
-    }
-  }
-}

package/src/components/eth.ts

@@ -1,3 +0,0 @@
-import { HTTPProvider } from 'eth-connect'
-
-export const providerInstance = new HTTPProvider('https://rpc.decentraland.org/mainnet?project=sdk-commands')

package/src/components/fetch.ts

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

package/src/components/fs.ts

@@ -1,62 +0,0 @@
-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[]>
-  }
-
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await fs.promises.access(path, fs.constants.F_OK | fs.constants.R_OK)
-    return true
-  } catch (error) {
-    return false
-  }
-}
-async function directoryExists(path: string): Promise<boolean> {
-  try {
-    return (await fs.promises.lstat(path)).isDirectory()
-  } catch (error) {
-    return false
-  }
-}
-
-/**
- * @public
- */
-export function createFsComponent(): IFileSystemComponent {
-  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
-  }
-}

package/src/components/index.ts

@@ -1,26 +0,0 @@
-import { ILoggerComponent } from '@well-known-components/interfaces'
-import { createAnalyticsComponent, IAnalyticsComponent } from './analytics'
-import { createDCLInfoConfigComponent, IDCLInfoConfigComponent } from './dcl-info-config'
-import { createFetchComponent, IFetchComponent } from './fetch'
-import { createFsComponent, IFileSystemComponent } from './fs'
-import { createStdoutCliLogger } from './log'
-
-export type CliComponents = {
-  fs: IFileSystemComponent
-  fetch: IFetchComponent
-  logger: ILoggerComponent.ILogger
-  dclInfoConfig: IDCLInfoConfigComponent
-  analytics: IAnalyticsComponent
-}
-
-export async function initComponents(): Promise<CliComponents> {
-  const fsComponent = createFsComponent()
-  const dclInfoConfig = await createDCLInfoConfigComponent({ fs: fsComponent })
-  return {
-    fs: fsComponent,
-    fetch: createFetchComponent(),
-    logger: createStdoutCliLogger(),
-    dclInfoConfig,
-    analytics: await createAnalyticsComponent({ dclInfoConfig })
-  }
-}

package/src/components/log.ts

@@ -1,48 +0,0 @@
-import { ILoggerComponent } from '@well-known-components/interfaces'
-import { createColors } from 'colorette'
-import { CliError } from '../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: readonly unknown[]) => {
-  process.stderr.write(`${parameters.filter(($) => $ !== undefined).join('')}\n`)
-}
-
-// @see https://no-color.org
-// @see https://www.npmjs.com/package/chalk
-export const colors = createColors({
-  useColor: process.env.FORCE_COLOR !== '0' && !process.env.NO_COLOR
-})
-
-export function createStdoutCliLogger(): ILoggerComponent.ILogger {
-  return {
-    log(message, extra) {
-      stderr(message, extra && JSON.stringify(extra))
-    },
-    debug(message, extra) {
-      stderr(colors.blueBright('debug: '), message, extra && JSON.stringify(extra))
-    },
-    error(error, extra) {
-      stderr(colors.redBright('error: '), error, extra && JSON.stringify(extra))
-      /* istanbul ignore next */
-      if (!(error instanceof CliError) || process.env.DEBUG) {
-        // print the stacktrace if it is not a CliError
-        console.error(error)
-      }
-    },
-    info(message, extra) {
-      stderr(colors.blueBright('info: '), message, extra && JSON.stringify(extra))
-    },
-    warn(message, extra) {
-      stderr(colors.yellow('warning: '), message, extra && JSON.stringify(extra))
-    }
-  }
-}

package/src/index.ts

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-
-/* istanbul ignore file */
-
-import { getArgs } from './logic/args'
-import { CliError } from './logic/error'
-import { COMMANDS_PATH, getCommands } from './logic/commands'
-import { CliComponents, initComponents } from './components'
-import { printCommand } from './logic/beautiful-logs'
-import { colors } from './components/log'
-
-export interface Options {
-  args: ReturnType<typeof getArgs>
-  components: CliComponents
-}
-
-// leaving args as "any" since we don't know yet if we will use them
-type FileFn = (options: Options) => Promise<void>
-
-interface FileExports {
-  help?: FileFn
-  main?: FileFn
-  args?: ReturnType<typeof getArgs>
-}
-
-const listCommandsStr = (commands: string[]) => commands.map(($) => `\t *sdk-commands ${$} \n`).join('')
-
-const commandFnsAreValid = (fns: FileExports): fns is Required<FileExports> => {
-  const { help, main } = fns
-  if (!help || !main) {
-    throw new CliError(`Command does not follow implementation rules:
-      * Requires a "help" function
-      * Requires a "main" function
-    `)
-  }
-  return true
-}
-
-async function main() {
-  const helpMessage = (commands: string[]) => `Here is the list of commands:\n${listCommandsStr(commands)}`
-  const args = getArgs()
-  const command = process.argv[2]
-  const needsHelp = args['--help']
-  const components: CliComponents = await initComponents()
-
-  const commands = await getCommands(components)
-
-  if (!commands.includes(command)) {
-    if (needsHelp) {
-      components.logger.info(helpMessage(commands))
-      return
-    }
-    throw new CliError(`Command ${command} is invalid. ${helpMessage(commands)}`)
-  }
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const cmd = require(`${COMMANDS_PATH}/${command}`)
-
-  if (commandFnsAreValid(cmd)) {
-    await components.analytics.identify()
-    const options = { args: cmd.args, components }
-    if (needsHelp) {
-      await cmd.help(options)
-    } else {
-      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: Error) {
-  if (err instanceof CliError) {
-    console.error(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/src/logic/args.ts

@@ -1,19 +0,0 @@
-import arg, { Result } from 'arg'
-
-export type Args = {
-  [key: string]: string | StringConstructor | NumberConstructor | BooleanConstructor
-}
-
-// updating to TS 4.9 will prevent losing types when
-// enforcing type to be "Args" by using "satisfies Args"
-export const DEFAULT_ARGS = {
-  '--help': Boolean,
-  '--json': Boolean,
-  '-h': '--help'
-}
-
-export function getArgs(): Result<typeof DEFAULT_ARGS>
-export function getArgs<T extends Args>(args: T): Result<typeof DEFAULT_ARGS & T>
-export function getArgs<T extends Args>(args?: T) {
-  return arg({ ...DEFAULT_ARGS, ...args }, { permissive: true })
-}

package/src/logic/beautiful-logs.ts

@@ -1,26 +0,0 @@
-import { ILoggerComponent } from '@well-known-components/interfaces'
-import { colors } from '../components/log'
-
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { name, version } = require('../../package.json')
-
-export function printProgressStep(logger: ILoggerComponent.ILogger, log: string, currentStep: number, maxStep: number) {
-  logger.log(colors.dim(`[${currentStep}/${maxStep}]`) + ' ' + log)
-}
-
-export function printProgressInfo(logger: ILoggerComponent.ILogger, log: string) {
-  logger.log(colors.dim(log))
-}
-
-export function printCommand(logger: ILoggerComponent.ILogger, commandName: string) {
-  logger.log(colors.bold(`${name} ${commandName} v${version}`))
-}
-
-export function printSuccess(logger: ILoggerComponent.ILogger, operationSuccessfulMessage: string, summary: string) {
-  // print a space before the success callout
-  logger.log('')
-  logger.log(colors.greenBright(operationSuccessfulMessage))
-  if (typeof summary === 'string') {
-    logger.log(summary)
-  }
-}

package/src/logic/catalyst-requests.ts

@@ -1,31 +0,0 @@
-import { Entity } from '@dcl/schemas'
-import { fetch } from 'undici'
-
-export async function fetchEntityByPointer(
-  baseUrl: string,
-  pointers: string[]
-): Promise<{
-  baseUrl: string
-  deployments: Entity[]
-}> {
-  if (pointers.length === 0)
-    return {
-      baseUrl,
-      deployments: []
-    }
-
-  const activeEntities = baseUrl + '/content/entities/active'
-
-  const response = await fetch(activeEntities, {
-    method: 'post',
-    headers: { 'content-type': 'application/json', connection: 'close' },
-    body: JSON.stringify({ pointers })
-  })
-
-  const deployments: Entity[] = response.ok ? ((await response.json()) as Entity[]) : []
-
-  return {
-    baseUrl,
-    deployments
-  }
-}