@dcl/sdk-commands 7.0.0-4293371227.commit-54082c6 → 7.0.0-4294380152.commit-0d08b10

package/dist/components/analytics.js

@@ -46,7 +46,11 @@ async function createAnalyticsComponent({ dclInfoConfig }) {
                     cliVersion: await dclInfoConfig.getVersion(),
                     isCI: dclInfoConfig.isCI(),
                     isEditor: dclInfoConfig.isEditor(),
-                    devId: userId
+                    devId: userId,
+                    ecs: {
+                        ecsVersion: 'ecs7',
+                        packageVersion: await dclInfoConfig.getVersion()
+                    }
                 }
             };
             analytics.track(trackInfo, () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/sdk-commands",
-  "version": "7.0.0-4293371227.commit-54082c6",
+  "version": "7.0.0-4294380152.commit-0d08b10",
   "description": "",
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -16,7 +16,7 @@
   "author": "Decentraland",
   "license": "Apache-2.0",
   "dependencies": {
-    "@dcl/dcl-rollup": "7.0.6-4293371227.commit-54082c6",
+    "@dcl/dcl-rollup": "7.0.6-4294380152.commit-0d08b10",
     "@dcl/hashing": "1.1.3",
     "@dcl/mini-comms": "1.0.1-20230216163137.commit-a4c75be",
     "@dcl/protocol": "1.0.0-4114477251.commit-ccb88d6",
@@ -49,5 +49,8 @@
     "displayName": "SDK",
     "tsconfig": "./tsconfig.json"
   },
-  "commit": "54082c63f87b970864c7e4eab94db193656d6aaa"
+  "files": [
+    "dist"
+  ],
+  "commit": "0d08b10653a3c1b7ccac2fec26b0e3fdf2d6e98b"
 }

package/src/commands/build/index.ts

@@ -1,77 +0,0 @@
-import { resolve } from 'path'
-import { CliComponents } from '../../components'
-import { getArgs } from '../../logic/args'
-import { compile } from '@dcl/dcl-rollup/compile'
-import future from 'fp-future'
-import { assertValidProjectFolder, installDependencies, needsDependencies } from '../../logic/project-validations'
-import { getBaseCoords } from '../../logic/scene-validations'
-import { b64HashingFunction, getSceneJson } from '../../logic/project-files'
-
-interface Options {
-  args: Omit<typeof args, '_'>
-  components: Pick<CliComponents, 'fs' | 'logger' | 'dclInfoConfig' | 'analytics'>
-}
-
-export const args = getArgs({
-  '--watch': Boolean,
-  '-w': '--watch',
-  '--production': Boolean,
-  '-p': '--production',
-  '--skip-install': Boolean,
-  '--dir': String
-})
-
-export function help() {
-  return `
-  Usage: 'sdk-commands build [options]'
-    Options:'
-      -h, --help                Displays complete help
-      -w, --watch               Watch for file changes and build on change
-      -p, --production          Build without sourcemaps
-      --skip-install            Skip installing dependencies
-      --dir                     Path to directory to build
-
-    Example:
-    - Build your scene:
-      '$ sdk-commands build'
-  `
-}
-
-export async function main(options: Options) {
-  const projectRoot = resolve(process.cwd(), options.args['--dir'] || '.')
-  await assertValidProjectFolder(options.components, projectRoot)
-
-  const shouldInstallDeps = await needsDependencies(options.components, projectRoot)
-
-  if (shouldInstallDeps && !options.args['--skip-install']) {
-    await installDependencies(options.components, projectRoot)
-  }
-
-  const watch = !!options.args['--watch']
-
-  const watchingFuture = future<any>()
-
-  await compile({
-    project: projectRoot,
-    watch,
-    production: !!options.args['--production'],
-    watchingFuture
-  })
-
-  if (!watch) {
-    watchingFuture.resolve(null)
-  }
-  const sceneJson = await getSceneJson(options.components, projectRoot)
-  const coords = getBaseCoords(sceneJson)
-
-  await options.components.analytics.track('Build scene', {
-    projectHash: await b64HashingFunction(projectRoot),
-    coords,
-    isWorkspace: false
-  })
-
-  await watchingFuture
-
-  // track stuff...
-  // https://github.com/decentraland/cli/blob/main/src/commands/build.ts
-}

package/src/commands/export-static/index.ts

@@ -1,150 +0,0 @@
-import { resolve } from 'path'
-import { getArgs } from '../../logic/args'
-import { hashV1 } from '@dcl/hashing'
-import { CliComponents } from '../../components'
-import { assertValidProjectFolder } from '../../logic/project-validations'
-import { b64HashingFunction, getProjectContentMappings, getSceneJson } from '../../logic/project-files'
-import { CliError } from '../../logic/error'
-import { Entity, EntityType } from '@dcl/schemas'
-import { colors } from '../../components/log'
-import { printProgressInfo, printProgressStep, printSuccess } from '../../logic/beautiful-logs'
-import { createStaticRealm } from '../../logic/realm'
-import { getBaseCoords } from '../../logic/scene-validations'
-
-interface Options {
-  args: typeof args
-  components: Pick<CliComponents, 'fetch' | 'fs' | 'logger' | 'dclInfoConfig' | 'analytics'>
-}
-
-export const args = getArgs({
-  '--dir': String,
-  '--destination': String,
-  '--timestamp': String,
-  '--realmName': String,
-  '--baseUrl': String
-})
-
-export async function help() {
-  return `
-  Usage:
-    sdk-commands export-static --dir <directory> --destination <directory>
-
-  Description:
-
-    Exports all the contents of the scene as if they were uploaded to a content server
-
-  Options:
-
-    --dir <directory>         The project's root folder to export
-    --destination <directory> A path in which all the assets will be stored
-    --timestamp <timestamp>   A date to use in the deployable entity. Defaults to now()
-    --realmName <name>        Creates a /<name>/about endpoint to expose the current deployment as a realm. Requires --baseUrl
-    --baseUrl <baseUrl>       It is the public URL in which the --destination directory will be avaiable
-`
-}
-
-export async function main(options: Options) {
-  const { fs, logger } = options.components
-  const projectRoot = resolve(process.cwd(), options.args['--dir'] || '.')
-  const destDirectory = resolve(process.cwd(), options.args['--destination'] || '.')
-  const willCreateRealm = !!args['--realmName']
-  let currentStep = 1
-  const maxSteps = 3 + (willCreateRealm ? 1 : 0)
-
-  if (willCreateRealm && !args['--baseUrl']) {
-    throw new CliError(`--baseUrl is mandatory when --realmName is provided`)
-  }
-
-  if (willCreateRealm && !/^[a-z][a-z0-9-/]*$/i.test(args['--realmName']!)) {
-    throw new CliError(`--realmName has invalid characters`)
-  }
-
-  printProgressStep(logger, 'Reading project files...', currentStep++, maxSteps)
-
-  await fs.mkdir(destDirectory, { recursive: true })
-  if (!(await fs.directoryExists(destDirectory))) {
-    throw new CliError(`The destination path ${destDirectory} is not a directory`)
-  }
-
-  const project = await assertValidProjectFolder(options.components, projectRoot)
-  const filesToExport = await getProjectContentMappings(options.components, projectRoot, async (file) => {
-    return await hashV1(fs.createReadStream(resolve(projectRoot, file)))
-  })
-
-  printProgressStep(logger, 'Copying files...', currentStep++, maxSteps)
-
-  for (const { file, hash } of filesToExport) {
-    const src = resolve(projectRoot, file)
-    const dst = resolve(destDirectory, hash)
-
-    if (src.startsWith(destDirectory)) continue
-
-    printProgressInfo(logger, `> ${hash} -> ${file}`)
-
-    if (!(await fs.fileExists(dst))) {
-      const content = await fs.readFile(src)
-      await fs.writeFile(dst, content)
-    }
-  }
-
-  // entity with ID are the deployed ones, when we generate the entity the ID is not
-  // available because it is the result of hashing the following structure
-  const entity: Omit<Entity, 'id'> = {
-    content: filesToExport,
-    pointers: [],
-    timestamp: args['--timestamp'] ? new Date(args['--timestamp']).getTime() : Date.now(),
-    type: EntityType.SCENE,
-    // for now, the only valid export is for scenes
-    metadata: project.scene,
-    version: 'v3'
-  }
-
-  printProgressStep(logger, 'Generating files...', currentStep++, maxSteps)
-
-  // create the entity file and get the entityId
-  const entityRaw = Buffer.from(JSON.stringify(entity), 'utf8')
-  const entityId = await hashV1(entityRaw)
-  const dst = resolve(destDirectory, entityId)
-  await fs.writeFile(dst, entityRaw)
-
-  printProgressInfo(logger, `> ${entityId} -> [ENTITY FILE]`)
-
-  let urn = `urn:decentraland:entity:${entityId}`
-
-  if (args['--baseUrl']) {
-    urn += '?baseUrl=' + args['--baseUrl']
-    // baseUrl must end with /
-    if (!urn.endsWith('/')) urn += '/'
-  }
-
-  if (willCreateRealm) {
-    // prepare the realm object
-    printProgressStep(logger, 'Creating realm file...', currentStep++, maxSteps)
-    const realm = createStaticRealm()
-    const realmName = args['--realmName']!
-
-    realm.configurations!.scenesUrn = [urn]
-    realm.configurations!.realmName = realmName
-
-    // write the realm file
-    const realmDirectory = resolve(destDirectory, realmName)
-    await fs.mkdir(realmDirectory, { recursive: true })
-    if (!(await fs.directoryExists(realmDirectory))) {
-      throw new CliError(`The destination path ${realmDirectory} is not a directory`)
-    }
-    const dst = resolve(realmDirectory, 'about')
-    await fs.writeFile(dst, JSON.stringify(realm, null, 2))
-    printProgressInfo(logger, `> ${realmName}/about -> [REALM FILE]`)
-  }
-
-  printSuccess(logger, `Export finished!`, `=> The entity URN is ${colors.bold(urn)}`)
-  const sceneJson = await getSceneJson(options.components, projectRoot)
-  const coords = getBaseCoords(sceneJson)
-
-  await options.components.analytics.track('Export static', {
-    projectHash: await b64HashingFunction(projectRoot),
-    coords
-  })
-
-  return { urn, entityId, destination: destDirectory }
-}

package/src/commands/init/index.ts

@@ -1,68 +0,0 @@
-import { join, resolve } from 'path'
-
-import { getArgs } from '../../logic/args'
-import { CliError } from '../../logic/error'
-import { CliComponents } from '../../components'
-import { isDirectoryEmpty, download, extract } from '../../logic/fs'
-
-import { get as getRepo } from './repos'
-import { installDependencies, needsDependencies } from '../../logic/project-validations'
-
-interface Options {
-  args: typeof args
-  components: Pick<CliComponents, 'fetch' | 'fs' | 'logger' | 'dclInfoConfig' | 'analytics'>
-}
-
-export const args = getArgs({
-  '--yes': Boolean,
-  '-y': '--yes',
-  '--dir': String,
-  '--skip-install': Boolean
-})
-
-export async function help() {}
-
-export async function main(options: Options) {
-  const dir = resolve(process.cwd(), options.args['--dir'] || '.')
-  const isEmpty = await isDirectoryEmpty(options.components, dir)
-  const yes = options.args['--yes']
-
-  if (!isEmpty && !yes) {
-    throw new CliError('The target directory specified is not empty. Run this command with --yes to override.')
-  }
-
-  // download and extract template project
-  const scene = 'scene-template'
-  const { url, contentFolders } = getRepo(scene)
-  const zip = await download(options.components, url, join(dir, `${scene}.zip`))
-  await extract(zip, dir)
-  await options.components.fs.unlink(zip)
-  await moveFilesFromDirs(options.components, dir, contentFolders)
-
-  // npm install
-  const shouldInstallDeps = await needsDependencies(options.components, dir)
-  if (shouldInstallDeps && !options.args['--skip-install']) {
-    await installDependencies(options.components, dir)
-  }
-  await options.components.analytics.track('Scene created', { projectType: scene, url })
-}
-
-const moveFilesFromDir = async (components: Pick<CliComponents, 'fs'>, dir: string, folder: string) => {
-  const files = await components.fs.readdir(folder)
-  await Promise.all(
-    files.map(($) => {
-      const filePath = resolve(folder, $)
-      return components.fs.rename(filePath, resolve(dir, $))
-    })
-  )
-  await components.fs.rmdir(folder)
-}
-
-const moveFilesFromDirs = async (components: Pick<CliComponents, 'fs'>, dir: string, folders: string[]) => {
-  await Promise.all(
-    folders.map(($) => {
-      const folderPath = resolve(dir, $)
-      return moveFilesFromDir(components, dir, folderPath)
-    })
-  )
-}

package/src/commands/init/repos.ts

@@ -1,17 +0,0 @@
-type Scene = 'scene-template'
-
-type Repos = {
-  [key in Scene]: {
-    url: string
-    contentFolders: string[]
-  }
-}
-
-const REPOS: Repos = {
-  'scene-template': {
-    url: 'https://github.com/decentraland/sdk7-scene-template/archive/refs/heads/main.zip',
-    contentFolders: ['sdk7-scene-template-main']
-  }
-}
-
-export const get = (scene: Scene): Repos[Scene] => REPOS[scene]

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
-}