@learnpack/learnpack 2.1.44 → 2.1.46

package/src/commands/start.ts

@@ -1,339 +1,315 @@
-// import path from "path";
-import { flags } from "@oclif/command"
-
-import SessionCommand from "../utils/SessionCommand"
-import Console from "../utils/console"
-import socket from "../managers/socket"
-import TelemetryManager, { TStep } from "../managers/telemetry"
-import createServer from "../managers/server"
-import queue from "../utils/fileQueue"
-import {
-  decompress,
-  downloadEditor,
-  checkIfDirectoryExists,
-} from "../managers/file"
-import { prioritizeHTMLFile } from "../utils/misc"
-
-import { IGitpodData } from "../models/gitpod-data"
-import { IExercise, IExerciseData } from "../models/exercise-obj"
-import { eventManager } from "../utils/osOperations"
-import { cli } from "cli-ux"
-import { TOpenWindowData } from "../models/socket"
-import { checkNotInstalledPlugins } from "../utils/checkNotInstalled"
-
-export default class StartCommand extends SessionCommand {
-  static description = "Runs a small server with all the exercise instructions"
-
-  static flags = {
-    ...SessionCommand.flags,
-    port: flags.string({ char: "p", description: "server port" }),
-    host: flags.string({ char: "h", description: "server host" }),
-    disableGrading: flags.boolean({
-      char: "D",
-      description: "disble grading functionality",
-      default: false,
-    }),
-    // disableGrading: flags.boolean({char: 'dg', description: 'disble grading functionality', default: false }),
-    watch: flags.boolean({
-      char: "w",
-      description: "Watch for file changes",
-      default: false,
-    }),
-    editor: flags.string({
-      char: "e",
-      description: "[preview, extension]",
-      options: ["extension", "preview"],
-    }),
-    version: flags.string({
-      char: "v",
-      description: "E.g: 1.0.1",
-      default: undefined,
-    }),
-    grading: flags.string({
-      char: "g",
-      description: "[isolated, incremental]",
-      options: ["isolated", "incremental"],
-    }),
-    debug: flags.boolean({
-      char: "d",
-      description: "debugger mode for more verbage",
-      default: false,
-    }),
-  }
-
-  // 🛑 IMPORTANT
-  // Every command that will use the configManager needs this init method
-  async init() {
-    const { flags } = this.parse(StartCommand)
-    await this.initSession(flags)
-  }
-
-  async run() {
-    // get configuration object
-    const configObject = this.configManager?.get()
-
-    // TODO: console.log(this.config.platform); get the platfrom from Oclif
-    const hasXDG = await eventManager.checkXDGInstalled()
-
-    const installedPlugins = this.config.plugins.map(plugin => {
-      return `${plugin.pjson.name}`
-    })
-
-    const neededToInstallPlugins = checkNotInstalledPlugins(
-      configObject?.exercises || [],
-      installedPlugins
-    )
-    if (neededToInstallPlugins.length > 0) {
-      Console.error(
-        "These plugins are not installed but required: ",
-        neededToInstallPlugins
-      )
-      const confirmInstall = await cli.confirm(
-        "Do you want to install the needed plugins? (y/n)"
-      )
-      if (confirmInstall) {
-        Console.info("Installing the needed plugins...")
-        for await (const p of neededToInstallPlugins) {
-          await this.config.runCommand(`plugins:install`, [p])
-          Console.log(`Plugin ${p} installed`)
-        }
-
-        Console.log(
-          "All needed plugins installed, please restart LearnPack to load them."
-        )
-        Console.info("Run: $ learnpack start")
-        this.exit(0)
-      } else {
-        Console.error(
-          "You need to install the plugins to complete this exercise"
-        )
-        Console.info(
-          "To install the plugins run each of the following commands: "
-        )
-        for (const p of neededToInstallPlugins) {
-          Console.log(`learnpack plugins:install ${p}`)
-        }
-
-        this.exit(1)
-      }
-    }
-
-    if (configObject) {
-      const { config } = configObject
-
-      // build exerises
-      this.configManager?.buildIndex()
-
-      Console.debug(
-        `Grading: ${config?.grading} ${
-          config?.disabledActions?.includes("test") ? "(disabled)" : ""
-        }, editor: ${config?.editor.mode} ${config?.editor.version}, for ${
-          Array.isArray(configObject?.exercises) ?
-            configObject?.exercises.length :
-            0
-        } exercises found`
-      )
-
-      const appAlreadyExists = checkIfDirectoryExists(
-        `${config?.dirPath}/_app`
-      )
-
-      if (!appAlreadyExists) {
-        // download app and decompress
-        await downloadEditor(
-          config?.editor.version,
-          `${config?.dirPath}/app.tar.gz`
-        )
-
-        Console.info("Decompressing LearnPack UI, this may take a minute...")
-        await decompress(
-          `${config?.dirPath}/app.tar.gz`,
-          `${config?.dirPath}/_app/`
-        )
-      }
-
-      // listen to socket commands
-      if (config && this.configManager) {
-        const server = await createServer(
-          configObject,
-          this.configManager,
-          process.env.NODE_ENV === "test"
-        )
-        server.setMaxListeners(25)
-
-        // I should call a method to get the EventListener
-        const dispatcher = queue.dispatcher({
-          create: true,
-          path: `${config.dirPath}/vscode_queue.json`,
-        })
-
-        if (configObject.exercises) {
-          const agent = configObject.config?.editor.agent || ""
-          const path = configObject.config?.dirPath || ""
-          const tutorialSlug = configObject.config?.slug || ""
-
-          const steps = configObject.exercises.map(
-            (e: IExercise, index): TStep => ({
-              slug: e.slug,
-              position: e.position || index,
-              files: e.files,
-              ai_interactions: [],
-              compilations: [],
-              tests: [],
-              is_testeable: e.graded || false,
-            })
-          )
-          if (path && steps.length > 0) {
-            TelemetryManager.start(agent, steps, path, tutorialSlug)
-          }
-
-          if (config.telemetry) {
-            TelemetryManager.urls = config.telemetry
-          }
-        }
-
-        socket.start(config, server, false)
-
-        socket.on("open", (data: IGitpodData) => {
-          Console.debug("Opening these files: ", data)
-
-          const files = prioritizeHTMLFile(data.files)
-
-          if (config.editor.agent === "os") {
-            eventManager.enqueue(dispatcher.events.OPEN_FILES, files)
-          } else {
-            dispatcher.enqueue(dispatcher.events.OPEN_FILES, files)
-          }
-
-          socket.ready("Ready to compile...")
-        })
-
-        socket.on("open_window", (data: TOpenWindowData) => {
-          Console.debug("Opening window: ", data)
-          // cli.open(data.url); This uses XDG under the ground
-          if (
-            config.editor.agent === "os" &&
-            ((config.os === "linux" && hasXDG) || config.os !== "linux")
-          ) {
-            eventManager.enqueue(dispatcher.events.OPEN_WINDOW, data)
-          } else {
-            dispatcher.enqueue(dispatcher.events.OPEN_WINDOW, data)
-          }
-
-          socket.log("open_window", `URL ${data.url} opened in the browser`)
-        })
-
-        socket.on("reset", (exercise: IExerciseData) => {
-          try {
-            this.configManager?.reset(exercise.exerciseSlug)
-            socket.ready("Ready to compile...")
-          } catch (error) {
-            socket.error(
-              "compiler-error",
-              (error as TypeError).message ||
-                "There was an error reseting the exercise"
-            )
-            setTimeout(() => socket.ready("Ready to compile..."), 2000)
-          }
-        })
-
-        socket.on("build", async (data: IExerciseData) => {
-          const exercise = this.configManager?.getExercise(data.exerciseSlug)
-
-          if (!exercise?.language) {
-            socket.error(
-              "compiler-error",
-              "Impossible to detect language to build for " +
-                data.exerciseSlug +
-                "..."
-            )
-            return
-          }
-
-          socket.log(
-            "compiling",
-            "Building exercise " +
-              data.exerciseSlug +
-              " with " +
-              exercise.language +
-              "..."
-          )
-          await this.config.runHook("action", {
-            action: "compile",
-            socket,
-            configuration: config,
-            exercise,
-            telemetry: TelemetryManager,
-          })
-        })
-
-        socket.on("ai_interaction", (data: any) => {
-          const { stepPosition, event, eventData } = data
-          TelemetryManager.registerStepEvent(stepPosition, event, eventData)
-        })
-
-        socket.on("test", async (data: IExerciseData) => {
-          const exercise = this.configManager?.getExercise(data.exerciseSlug)
-
-          if (!exercise?.language) {
-            socket.error(
-              "compiler-error",
-              "Impossible to detect engine language for testing for " +
-                data.exerciseSlug +
-                "..."
-            )
-            return
-          }
-
-          if (
-            config?.disabledActions!.includes("test") ||
-            config?.disableGrading
-          ) {
-            socket.ready("Grading is disabled on configuration")
-            return true
-          }
-
-          socket.log(
-            "testing",
-            "Testing your exercise using the " + exercise.language + " engine."
-          )
-
-          await this.config.runHook("action", {
-            action: "test",
-            socket,
-            configuration: config,
-            exercise,
-            telemetry: TelemetryManager,
-          })
-
-          this.configManager?.save()
-
-          return true
-        })
-
-        const terminate = async () => {
-          Console.error("Terminating Learnpack...")
-          await TelemetryManager.submit()
-          this.configManager?.noCurrentExercise()
-          dispatcher.enqueue(dispatcher.events.END)
-          process.exit()
-        }
-
-        server.on("close", terminate)
-        process.on("SIGINT", terminate)
-        process.on("SIGTERM", terminate)
-        process.on("SIGHUP", terminate)
-
-        // finish the server startup
-        setTimeout(() => dispatcher.enqueue(dispatcher.events.RUNNING), 1000)
-
-        // start watching for file changes
-        if (StartCommand.flags.watch)
-          this.configManager.watchIndex(_filename => {
-            // Instead of reloading with socket.reload(), I just notify the frontend for the file change
-            socket.emit("file_change", "ready", _filename)
-          })
-      }
-    }
-  }
-}
+// import path from "path";
+import { flags } from "@oclif/command"
+
+import SessionCommand from "../utils/SessionCommand"
+import Console from "../utils/console"
+import socket from "../managers/socket"
+import TelemetryManager, { TStep } from "../managers/telemetry"
+import createServer from "../managers/server"
+import queue from "../utils/fileQueue"
+import {
+  decompress,
+  downloadEditor,
+  checkIfDirectoryExists,
+} from "../managers/file"
+import { prioritizeHTMLFile } from "../utils/misc"
+
+import { IGitpodData } from "../models/gitpod-data"
+import { IExercise, IExerciseData } from "../models/exercise-obj"
+import { eventManager } from "../utils/osOperations"
+import { cli } from "cli-ux"
+import { TOpenWindowData } from "../models/socket"
+import {
+  checkNotInstalledPlugins,
+  checkNotInstalledDependencies,
+} from "../utils/checkNotInstalled"
+
+export default class StartCommand extends SessionCommand {
+  static description = "Runs a small server with all the exercise instructions"
+
+  static flags = {
+    ...SessionCommand.flags,
+    port: flags.string({ char: "p", description: "server port" }),
+    host: flags.string({ char: "h", description: "server host" }),
+    disableGrading: flags.boolean({
+      char: "D",
+      description: "disble grading functionality",
+      default: false,
+    }),
+    // disableGrading: flags.boolean({char: 'dg', description: 'disble grading functionality', default: false }),
+    watch: flags.boolean({
+      char: "w",
+      description: "Watch for file changes",
+      default: false,
+    }),
+    editor: flags.string({
+      char: "e",
+      description: "[preview, extension]",
+      options: ["extension", "preview"],
+    }),
+    version: flags.string({
+      char: "v",
+      description: "E.g: 1.0.1",
+      default: undefined,
+    }),
+    grading: flags.string({
+      char: "g",
+      description: "[isolated, incremental]",
+      options: ["isolated", "incremental"],
+    }),
+    debug: flags.boolean({
+      char: "d",
+      description: "debugger mode for more verbage",
+      default: false,
+    }),
+  }
+
+  // 🛑 IMPORTANT
+  // Every command that will use the configManager needs this init method
+  async init() {
+    const { flags } = this.parse(StartCommand)
+    await this.initSession(flags)
+  }
+
+  async run() {
+    // get configuration object
+    const configObject = this.configManager?.get()
+
+    // TODO: console.log(this.config.platform); get the platfrom from Oclif
+    const hasXDG = await eventManager.checkXDGInstalled()
+
+    const installedPlugins = this.config.plugins.map(plugin => {
+      return `${plugin.pjson.name}`
+    })
+
+    if (configObject) {
+      const { config } = configObject
+      // build exerises
+      this.configManager?.buildIndex()
+
+      Console.debug(
+        `Grading: ${config?.grading} ${
+          config?.disabledActions?.includes("test") ? "(disabled)" : ""
+        }, editor: ${config?.editor.mode} ${config?.editor.version}, for ${
+          Array.isArray(configObject?.exercises) ?
+            configObject?.exercises.length :
+            0
+        } exercises found`
+      )
+
+      const neededPlugins = await checkNotInstalledPlugins(
+        configObject?.exercises || [],
+        installedPlugins,
+        this
+      )
+
+      const allDepsInstalled = await checkNotInstalledDependencies(
+        neededPlugins.needed
+      )
+      if (!allDepsInstalled) {
+        this.exit(1)
+      }
+
+      const appAlreadyExists = checkIfDirectoryExists(
+        `${config?.dirPath}/_app`
+      )
+
+      if (!appAlreadyExists) {
+        // download app and decompress
+        await downloadEditor(
+          config?.editor.version,
+          `${config?.dirPath}/app.tar.gz`
+        )
+
+        Console.info("Decompressing LearnPack UI, this may take a minute...")
+        await decompress(
+          `${config?.dirPath}/app.tar.gz`,
+          `${config?.dirPath}/_app/`
+        )
+      }
+
+      // listen to socket commands
+      if (config && this.configManager) {
+        const server = await createServer(
+          configObject,
+          this.configManager,
+          process.env.NODE_ENV === "test"
+        )
+        server.setMaxListeners(25)
+
+        // I should call a method to get the EventListener
+        const dispatcher = queue.dispatcher({
+          create: true,
+          path: `${config.dirPath}/vscode_queue.json`,
+        })
+
+        if (configObject.exercises) {
+          const agent = configObject.config?.editor.agent || ""
+          const path = configObject.config?.dirPath || ""
+          const tutorialSlug = configObject.config?.slug || ""
+
+          const steps = configObject.exercises.map(
+            (e: IExercise, index): TStep => ({
+              slug: e.slug,
+              position: e.position || index,
+              files: e.files,
+              ai_interactions: [],
+              compilations: [],
+              tests: [],
+              is_testeable: e.graded || false,
+            })
+          )
+          if (path && steps.length > 0) {
+            TelemetryManager.start(agent, steps, path, tutorialSlug)
+          }
+
+          if (config.telemetry) {
+            TelemetryManager.urls = config.telemetry
+          }
+        }
+
+        socket.start(config, server, false)
+
+        socket.on("open", (data: IGitpodData) => {
+          Console.debug("Opening these files: ", data)
+
+          const files = prioritizeHTMLFile(data.files)
+
+          if (config.editor.agent === "os") {
+            eventManager.enqueue(dispatcher.events.OPEN_FILES, files)
+          } else {
+            dispatcher.enqueue(dispatcher.events.OPEN_FILES, files)
+          }
+
+          socket.ready("Ready to compile...")
+        })
+
+        socket.on("open_window", (data: TOpenWindowData) => {
+          Console.debug("Opening window: ", data)
+          // cli.open(data.url); This uses XDG under the ground
+          if (
+            config.editor.agent === "os" &&
+            ((config.os === "linux" && hasXDG) || config.os !== "linux")
+          ) {
+            eventManager.enqueue(dispatcher.events.OPEN_WINDOW, data)
+          } else {
+            dispatcher.enqueue(dispatcher.events.OPEN_WINDOW, data)
+          }
+
+          socket.log("open_window", `URL ${data.url} opened in the browser`)
+        })
+
+        socket.on("reset", (exercise: IExerciseData) => {
+          try {
+            this.configManager?.reset(exercise.exerciseSlug)
+            socket.ready("Ready to compile...")
+          } catch (error) {
+            socket.error(
+              "compiler-error",
+              (error as TypeError).message ||
+                "There was an error reseting the exercise"
+            )
+            setTimeout(() => socket.ready("Ready to compile..."), 2000)
+          }
+        })
+
+        socket.on("build", async (data: IExerciseData) => {
+          const exercise = this.configManager?.getExercise(data.exerciseSlug)
+
+          if (!exercise?.language) {
+            socket.error(
+              "compiler-error",
+              "Impossible to detect language to build for " +
+                data.exerciseSlug +
+                "..."
+            )
+            return
+          }
+
+          socket.log(
+            "compiling",
+            "Building exercise " +
+              data.exerciseSlug +
+              " with " +
+              exercise.language +
+              "..."
+          )
+          await this.config.runHook("action", {
+            action: "compile",
+            socket,
+            configuration: config,
+            exercise,
+            telemetry: TelemetryManager,
+          })
+        })
+
+        socket.on("ai_interaction", (data: any) => {
+          const { stepPosition, event, eventData } = data
+          TelemetryManager.registerStepEvent(stepPosition, event, eventData)
+        })
+
+        socket.on("test", async (data: IExerciseData) => {
+          const exercise = this.configManager?.getExercise(data.exerciseSlug)
+
+          if (!exercise?.language) {
+            socket.error(
+              "compiler-error",
+              "Impossible to detect engine language for testing for " +
+                data.exerciseSlug +
+                "..."
+            )
+            return
+          }
+
+          if (
+            config?.disabledActions!.includes("test") ||
+            config?.disableGrading
+          ) {
+            socket.ready("Grading is disabled on configuration")
+            return true
+          }
+
+          socket.log(
+            "testing",
+            "Testing your exercise using the " + exercise.language + " engine."
+          )
+
+          await this.config.runHook("action", {
+            action: "test",
+            socket,
+            configuration: config,
+            exercise,
+            telemetry: TelemetryManager,
+          })
+
+          this.configManager?.save()
+
+          return true
+        })
+
+        const terminate = async () => {
+          Console.error("Terminating Learnpack...")
+          await TelemetryManager.submit()
+          this.configManager?.noCurrentExercise()
+          dispatcher.enqueue(dispatcher.events.END)
+          process.exit()
+        }
+
+        server.on("close", terminate)
+        process.on("SIGINT", terminate)
+        process.on("SIGTERM", terminate)
+        process.on("SIGHUP", terminate)
+
+        // finish the server startup
+        setTimeout(() => dispatcher.enqueue(dispatcher.events.RUNNING), 1000)
+
+        // start watching for file changes
+        if (StartCommand.flags.watch)
+          this.configManager.watchIndex(_filename => {
+            // Instead of reloading with socket.reload(), I just notify the frontend for the file change
+            socket.emit("file_change", "ready", _filename)
+          })
+      }
+    }
+  }
+}