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

package/src/commands/start/index.ts

@@ -1,221 +0,0 @@
-import * as os from 'os'
-import * as path from 'path'
-import open from 'open'
-import future from 'fp-future'
-
-import { CliComponents } from '../../components'
-import { main as build } from '../build'
-import { getArgs } from '../../logic/args'
-import { needsDependencies, npmRun } from '../../logic/project-validations'
-import { getBaseCoords, validateSceneJson } from '../../logic/scene-validations'
-import { CliError } from '../../logic/error'
-import { previewPort } from '../../logic/get-free-port'
-import { ISignalerComponent, PreviewComponents } from './types'
-import { createTestMetricsComponent } from '@well-known-components/metrics'
-import { Lifecycle, IBaseComponent } from '@well-known-components/interfaces'
-import { createRecordConfigComponent } from '@well-known-components/env-config-provider'
-import { createRoomsComponent, roomsMetrics } from '@dcl/mini-comms/dist/adapters/rooms'
-import { createServerComponent } from '@well-known-components/http-server'
-import { createConsoleLogComponent } from '@well-known-components/logger'
-import { providerInstance } from '../../components/eth'
-import { createStdoutCliLogger } from '../../components/log'
-import { wireFileWatcherToWebSockets } from './server/file-watch-notifier'
-import { wireRouter } from './server/routes'
-import { createWsComponent } from './server/ws'
-import { b64HashingFunction, getSceneJson } from '../../logic/project-files'
-
-interface Options {
-  args: typeof args
-  components: Pick<CliComponents, 'fetch' | 'fs' | 'logger' | 'dclInfoConfig' | 'analytics'>
-}
-
-export const args = 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
-})
-
-export 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
-`
-}
-
-export async function main(options: Options) {
-  const projectRoot = path.resolve(process.cwd(), options.args['--dir'] || '.')
-  const isCi = args['--ci'] || process.env.CI || false
-  const debug = !args['--no-debug'] && !isCi
-  const openBrowser = !args['--no-browser'] && !isCi
-  const skipBuild = args['--skip-build']
-  const watch = !args['--no-watch']
-  const enableWeb3 = 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 npmRun(projectRoot, 'build')
-  }
-
-  // then start the embedded compiler, this can be disabled with --no-watch
-  if (watch) {
-    await build({ ...options, args: { '--dir': projectRoot, '--watch': watch } })
-  }
-
-  await validateSceneJson(options.components, projectRoot)
-  const sceneJson = await getSceneJson(options.components, projectRoot)
-  const baseCoords = getBaseCoords(sceneJson)
-
-  if (await needsDependencies(options.components, projectRoot)) {
-    const npmModulesPath = path.resolve(projectRoot, 'node_modules')
-    throw new CliError(`Couldn\'t find ${npmModulesPath}, please run: npm install`)
-  }
-
-  const port = options.args['--port'] || (await previewPort())
-
-  const program = await Lifecycle.run<PreviewComponents>({
-    async initComponents() {
-      const metrics = createTestMetricsComponent(roomsMetrics)
-      const config = createRecordConfigComponent({
-        HTTP_SERVER_PORT: port.toString(),
-        HTTP_SERVER_HOST: '0.0.0.0',
-        ...process.env
-      })
-      const logs = await createConsoleLogComponent({})
-      const ws = await createWsComponent({ logs })
-      const server = await createServerComponent<PreviewComponents>({ config, logs, ws: ws.ws }, {})
-      const rooms = await createRoomsComponent({
-        metrics,
-        logs,
-        config
-      })
-
-      const programClosed = future<void>()
-      const signaler: IBaseComponent & ISignalerComponent = {
-        programClosed,
-        async stop() {
-          // this promise is resolved upon SIGTERM or SIGHUP
-          // or when program.stop is called
-          programClosed.resolve()
-        }
-      }
-
-      return {
-        ...options.components,
-        logger: createStdoutCliLogger(),
-        logs,
-        ethereumProvider: providerInstance,
-        rooms,
-        config,
-        metrics,
-        server,
-        ws,
-        signaler
-      }
-    },
-    async main({ components, startComponents }) {
-      await wireRouter(components, projectRoot)
-      if (watch) {
-        await wireFileWatcherToWebSockets(components, projectRoot)
-      }
-      await startComponents()
-
-      const networkInterfaces = os.networkInterfaces()
-      const availableURLs: string[] = []
-      await components.analytics.track('Preview started', {
-        projectHash: await b64HashingFunction(projectRoot),
-        coords: baseCoords,
-        isWorkspace: false
-      })
-      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 (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 && !args['--desktop-client']) {
-        try {
-          await open(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
-}

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

@@ -1,471 +0,0 @@
-import { Router } from '@well-known-components/http-server'
-import { PreviewComponents } from '../types'
-import * as path from 'path'
-import { WearableJson } from '@dcl/schemas/dist/sdk'
-import { Entity, EntityType, Locale, Wearable } from '@dcl/schemas'
-import fetch, { Headers } from 'node-fetch'
-import { fetchEntityByPointer } from '../../../logic/catalyst-requests'
-import { CliComponents } from '../../../components'
-import { b64HashingFunction, getProjectContentMappings } from '../../../logic/project-files'
-
-function getCatalystUrl(): URL {
-  return new URL('https://peer.decentraland.org')
-}
-
-function smartWearableNameToId(name: string) {
-  return name.toLocaleLowerCase().replace(/ /g, '-')
-}
-
-type LambdasWearable = Wearable & {
-  baseUrl: string
-}
-
-export function setupEcs6Endpoints(components: CliComponents, dir: string, router: Router<PreviewComponents>) {
-  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 fetch(u.toString(), {
-          headers: {
-            connection: 'close'
-          },
-          method: ctx.request.method,
-          body: ctx.request.method === 'get' ? undefined : ctx.request.body
-        })
-
-        const deployedProfile = (await req.json()) as any[]
-
-        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 fetch(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 Headers()
-    console.log(ctx.request.headers)
-    const res = await fetch(`${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)
-}
-
-function serveFolders(components: Pick<CliComponents, 'fs'>, router: Router<PreviewComponents>, baseFolders: string[]) {
-  router.get('/content/contents/:hash', async (ctx: any, next: any) => {
-    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: string) => 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: string[]) {
-    if (!pointers || pointers.length === 0) {
-      return []
-    }
-
-    const requestedPointers = new Set<string>(
-      pointers && typeof pointers === 'string' ? [pointers as string] : (pointers as string[])
-    )
-
-    const resultEntities = await getSceneJson(components, baseFolders, Array.from(requestedPointers))
-    const catalystUrl = getCatalystUrl()
-    const remote = fetchEntityByPointer(
-      catalystUrl.toString(),
-      pointers.filter(($: string) => !$.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 })
-      }
-    }
-  })
-}
-
-async function getAllPreviewWearables(
-  components: Pick<CliComponents, 'fs'>,
-  { baseFolders, baseUrl }: { baseFolders: string[]; baseUrl: string }
-) {
-  const wearablePathArray: string[] = []
-  for (const wearableDir of baseFolders) {
-    const wearableJsonPath = path.resolve(wearableDir, 'wearable.json')
-    if (await components.fs.fileExists(wearableJsonPath)) {
-      wearablePathArray.push(wearableJsonPath)
-    }
-  }
-
-  const ret: LambdasWearable[] = []
-  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: Pick<CliComponents, 'fs'>,
-  wearableJsonPath: string,
-  baseUrl: string
-): Promise<LambdasWearable> {
-  const wearableDir = path.dirname(wearableJsonPath)
-  const wearableJson = JSON.parse((await components.fs.readFile(wearableJsonPath)).toString())
-
-  if (!WearableJson.validate(wearableJson)) {
-    const errors = (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 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' as Locale, 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 as any
-      // scene: hashedFiles as any,
-    }
-  }
-}
-
-async function getSceneJson(
-  components: Pick<CliComponents, 'fs'>,
-  projectRoots: string[],
-  pointers: string[]
-): Promise<Entity[]> {
-  const requestedPointers = new Set<string>(pointers)
-  const resultEntities: Entity[] = []
-
-  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: Pick<CliComponents, 'fs'>, projectRoot: string, router: Router<PreviewComponents>) {
-  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: Pick<CliComponents, 'fs'>,
-    route: string,
-    folder: string,
-    transform = (str: string) => 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: Record<string, any> = {
-        '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 fetch(`https://feature-flags.decentraland.zone/${ctx.params.file}`, {
-      headers: {
-        connection: 'close'
-      }
-    })
-    return {
-      body: await res.arrayBuffer()
-    }
-  })
-}
-
-async function fakeEntityV3FromFolder(
-  components: Pick<CliComponents, 'fs'>,
-  projectRoot: string,
-  hashingFunction: (filePath: string) => Promise<string>
-): Promise<Entity | null> {
-  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 (!WearableJson.validate(wearableJson)) {
-        const errors = (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 }: { base: string; parcels: string[] } = sceneJson.scene
-    const pointers = new Set<string>()
-    pointers.add(base)
-    parcels.forEach(($) => pointers.add($))
-
-    const mappedFiles = await getProjectContentMappings(components, projectRoot, hashingFunction)
-
-    return {
-      version: 'v3',
-      type: EntityType.SCENE,
-      id: await hashingFunction(projectRoot),
-      pointers: Array.from(pointers),
-      timestamp: Date.now(),
-      metadata: sceneJson,
-      content: mappedFiles
-    }
-  }
-
-  return null
-}