@learnpack/learnpack 2.1.25 → 2.1.27

package/src/managers/server/routes.ts

@@ -1,78 +1,117 @@
-import Console from "../../utils/console";
-import * as express from "express";
-import * as fs from "fs";
-import * as bodyParser from "body-parser";
-import socket from "../socket";
-import queue from "../../utils/fileQueue";
+import Console from "../../utils/console"
+import * as express from "express"
+import * as fs from "fs"
+import * as bodyParser from "body-parser"
+import socket from "../socket"
+import queue from "../../utils/fileQueue"
 // import gitpod from '../gitpod'
-import { detect, filterFiles } from "../config/exercise";
-import { IFile } from "../../models/file";
-import { IConfigObj, TEntries } from "../../models/config";
-import { IConfigManager } from "../../models/config-manager";
-import { IExercise } from "../../models/exercise-obj";
+import { detect, filterFiles } from "../config/exercise"
+import { IFile } from "../../models/file"
+import { IConfigObj, TEntries } from "../../models/config"
+import { IConfigManager } from "../../models/config-manager"
+import { IExercise } from "../../models/exercise-obj"
+import SessionManager from "../../managers/session"
 
 const withHandler =
   (func: (req: express.Request, res: express.Response) => void) =>
   (req: express.Request, res: express.Response) => {
     try {
-      func(req, res);
+      func(req, res)
     } catch (error) {
-      Console.debug(error);
+      Console.debug(error)
       const _err = {
         message: (error as TypeError).message || "There has been an error",
         status: (error as any).status || 500,
         type: (error as any).type || null,
-      };
-      Console.error(_err.message);
+      }
+      Console.error(_err.message)
 
       // send rep to the server
-      res.status(_err.status);
-      res.json(_err);
+      res.status(_err.status)
+      res.json(_err)
     }
-  };
+  }
 
 export default async function (
   app: express.Application,
   configObject: IConfigObj,
   configManager: IConfigManager
 ) {
-  const { config, exercises } = configObject;
+  const { config, exercises } = configObject
+  const session = await SessionManager.get(configManager?.get())
 
   const dispatcher = queue.dispatcher({
     create: true,
     path: `${config?.dirPath}/vscode_queue.json`,
-  });
+  })
   app.get(
     "/config",
     withHandler((_: express.Request, res: express.Response) => {
-      res.json(configObject);
+      res.json(configObject)
     })
-  );
+  )
 
-  /**
-     * TODO: replicate a socket action, the request payload must be passed to the socket as well
-  
-   const jsonBodyParser = bodyParser.json()
-   
-   type ISocketActions = "addAllowed" | "removeAllowed" | "start" | "on" | "clean" | "ask" | "reload" | "openWindow" | "log" | "emit" | "ready" | "error" | "fatal" | "success" | "onTestingFinished";
-   
-   app.post('/socket/:actionName', jsonBodyParser, withHandler((req, res) => {
-     if (socket[req.params.actionName as ISocketActions] instanceof Function) {
-       socket[req.params.actionName as ISocketActions](req.body ? req.body.data : null)
-       res.json({ "details": "Socket call executed sucessfully" })
-      } else res.status(400).json({ "details": `Socket action ${req.params.actionName} not found` })
-    }))
-  */
+  // Added this line to parse the json body
+
+  const jsonBodyParser = bodyParser.json()
+  // Trying to log in from frontend
+  app.post(
+    "/login",
+    jsonBodyParser,
+    withHandler(async (req: express.Request, res: express.Response) => {
+      const email = req.body.email
+      const password = req.body.password
+
+      SessionManager.destroy()
+      const payload = await SessionManager.loginWeb(email, password)
+
+      res.json(payload)
+    })
+  )
+  app.post(
+    "/set-openai-token",
+    jsonBodyParser,
+    withHandler(async (req: express.Request, res: express.Response) => {
+      const token = req.body.token
+      console.log("Setting openai token")
+
+      const tokenSaved = await SessionManager.setOpenAIToken(token)
+      if (tokenSaved) {
+        res.json({ status: "ok" })
+      } else {
+        res.status(400)
+      }
+    })
+  )
+
+  app.get(
+    "/check/rigo/status",
+    withHandler(async (_: express.Request, res: express.Response) => {
+      const payload = await SessionManager.getPayload()
+      const openaiToken = await SessionManager.getOpenAIToken()
+      // console.log("Looking Rigo creds");
+
+      if (payload && payload.rigobot && payload.rigobot.key) {
+        res.json({ rigoToken: payload.rigobot.key })
+      } else if (openaiToken) {
+        res.json({ openaiToken })
+      } else {
+        res
+          .status(400)
+          .json({ details: `Rigobot token not found, please log in first!` })
+      }
+    })
+  )
 
   // symbolic link to maintain path compatiblity
   const fetchStaticAsset = withHandler((req, res) => {
-    const filePath = `${config?.dirPath}/assets/${req.params.filePath}`;
+    const filePath = `${config?.dirPath}/assets/${req.params.filePath}`
     if (!fs.existsSync(filePath))
-      throw new Error("File not found: " + filePath);
-    const content = fs.readFileSync(filePath);
-    res.write(content);
-    res.end();
-  });
+      throw new Error("File not found: " + filePath)
+    const content = fs.readFileSync(filePath)
+    res.write(content)
+    res.end()
+  })
 
   app.get(
     `${
@@ -81,16 +120,16 @@ export default async function (
         config?.dirPath
     }/assets/:filePath`,
     fetchStaticAsset
-  );
+  )
 
-  app.get("/assets/:filePath", fetchStaticAsset);
+  app.get("/assets/:filePath", fetchStaticAsset)
 
   app.get(
     "/exercise",
     withHandler((_: express.Request, res: express.Response) => {
-      res.json(exercises);
+      res.json(exercises)
     })
-  );
+  )
 
   app.get(
     "/exercise/:slug/readme",
@@ -99,30 +138,30 @@ export default async function (
         { params: { slug }, query: { lang } }: express.Request,
         res: express.Response
       ) => {
-        const exercise: IExercise = configManager.getExercise(slug);
+        const exercise: IExercise = configManager.getExercise(slug)
 
         if (exercise && exercise.getReadme) {
-          const readme = exercise.getReadme((lang as string) || null);
-          res.json(readme);
+          const readme = exercise.getReadme((lang as string) || null)
+          res.json(readme)
         } else {
-          res.status(400);
+          res.status(400)
         }
       }
     )
-  );
+  )
 
   app.get(
     "/exercise/:slug/report",
     withHandler(
       ({ params: { slug } }: express.Request, res: express.Response) => {
-        const exercise = configManager.getExercise(slug);
+        const exercise = configManager.getExercise(slug)
         if (exercise && exercise.getTestReport) {
-          const report = exercise.getTestReport();
-          res.json(JSON.stringify(report));
+          const report = exercise.getTestReport()
+          res.json(JSON.stringify(report))
         }
       }
     )
-  );
+  )
 
   app.get(
     "/exercise/:slug",
@@ -132,13 +171,13 @@ export default async function (
         configObject.currentExercise &&
         req.params.slug === configObject.currentExercise
       ) {
-        const exercise = configManager.getExercise(req.params.slug);
-        res.json(exercise);
-        return;
+        const exercise = configManager.getExercise(req.params.slug)
+        res.json(exercise)
+        return
       }
 
-      const exercise = configManager.startExercise(req.params.slug);
-      dispatcher.enqueue(dispatcher.events.START_EXERCISE, req.params.slug);
+      const exercise = configManager.startExercise(req.params.slug)
+      dispatcher.enqueue(dispatcher.events.START_EXERCISE, req.params.slug)
 
       type TEntry = "python3" | "html" | "node" | "react" | "java";
 
@@ -146,19 +185,19 @@ export default async function (
         Object.keys(config?.entries!).map(
           lang => config?.entries[lang as TEntry]
         )
-      );
+      )
 
       // if we are in incremental grading, the entry file can by dinamically detected
       // based on the changes the student is making during the exercise
       if (config?.grading === "incremental") {
-        const scanedFiles = fs.readdirSync("./");
+        const scanedFiles = fs.readdirSync("./")
 
         // update the file hierarchy with updates
         exercise.files = [
           ...exercise.files.filter(f => f.name.includes("test.")),
           ...filterFiles(scanedFiles),
-        ];
-        Console.debug(`Exercise updated files: `, exercise.files);
+        ]
+        Console.debug(`Exercise updated files: `, exercise.files)
       }
 
       const detected = detect(
@@ -166,31 +205,31 @@ export default async function (
         exercise.files
           .filter(fileName => entries.has(fileName.name))
           .map(f => f.name || f) as string[]
-      );
+      )
 
       // if a new language for the testing engine is detected, we replace it
       // if not we leave it as it was before
       if (config?.language && !["", "auto"].includes(config?.language)) {
         Console.debug(
           `Exercise language ignored, instead imported from configuration ${config?.language}`
-        );
-        exercise.language = detected?.language;
+        )
+        exercise.language = detected?.language
       } else if (
         detected?.language &&
         (!config?.language || config?.language === "auto")
       ) {
         Console.debug(
           `Switching to ${detected.language} engine in this exercise`
-        );
-        exercise.language = detected.language;
+        )
+        exercise.language = detected.language
       }
 
       // WARNING: has to be the FULL PATH to the entry path
       // We need to detect entry in both gradings: Incremental and Isolate
-      exercise.entry = detected?.entry;
+      exercise.entry = detected?.entry
       Console.debug(
         `Exercise detected entry: ${detected?.entry} and language ${exercise.language}`
-      );
+      )
 
       // exercises.graded and exercises.disableGrading deprecated.
       if (
@@ -198,15 +237,15 @@ export default async function (
         config?.disableGrading ||
         config?.disabledActions?.includes("test")
       ) {
-        socket.removeAllowed("test");
+        socket.removeAllowed("test")
       } else {
-        socket.addAllowed("test");
+        socket.addAllowed("test")
       }
 
       if (!exercise.entry || config?.disabledActions?.includes("build")) {
-        socket.removeAllowed("build");
+        socket.removeAllowed("build")
       } else {
-        socket.addAllowed("build");
+        socket.addAllowed("build")
       }
 
       if (
@@ -217,44 +256,54 @@ export default async function (
         ).length === 0 ||
         config?.disabledActions?.includes("reset")
       ) {
-        socket.removeAllowed("reset");
+        socket.removeAllowed("reset")
       } else if (!config?.disabledActions?.includes("reset")) {
-        socket.addAllowed("reset");
+        socket.addAllowed("reset")
       }
 
-      socket.log("ready");
+      socket.log("ready")
 
-      res.json(exercise);
+      res.json(exercise)
     })
-  );
+  )
 
   app.get(
     "/exercise/:slug/file/:fileName",
     withHandler((req: express.Request, res: express.Response) => {
-      const exercise = configManager.getExercise(req.params.slug);
+      const exercise = configManager.getExercise(req.params.slug)
       if (exercise && exercise.getFile) {
-        res.write(exercise.getFile(req.params.fileName));
-        res.end();
+        res.write(exercise.getFile(req.params.fileName))
+        res.end()
       }
     })
+  )
+
+  /*
+  app.post(
+    "/exercise/:slug/file/:fileName",
+    withHandler((req: express.Request, res: express.Response) => {
+      get tokens but also, add allowed action for 'generate'
+      use the sessionManager to keep compatibility with the cli login command.
+    })
   );
+  */
 
-  const textBodyParser = bodyParser.text();
+  const textBodyParser = bodyParser.text()
   app.put(
     "/exercise/:slug/file/:fileName",
     textBodyParser,
     withHandler((req: express.Request, res: express.Response) => {
-      const exercise = configManager.getExercise(req.params.slug);
+      const exercise = configManager.getExercise(req.params.slug)
       if (exercise && exercise.saveFile) {
-        exercise.saveFile(req.params.fileName, req.body);
-        res.end();
+        exercise.saveFile(req.params.fileName, req.body)
+        res.end()
       }
     })
-  );
+  )
 
   if (config?.outputPath) {
-    app.use("/preview", express.static(config.outputPath));
+    app.use("/preview", express.static(config.outputPath))
   }
 
-  app.use("/", express.static(`${config?.dirPath}/_app`));
+  app.use("/", express.static(`${config?.dirPath}/_app`))
 }

package/src/managers/session.ts

@@ -1,118 +1,147 @@
-import Console from '../utils/console'
-import api from '../utils/api'
-
-import v from 'validator'
-import {ValidationError, InternalError} from '../utils/errors'
-// import moment from 'moment'
-import * as fs from 'fs'
-import cli from 'cli-ux'
-import * as storage from 'node-persist'
-
-import {IPayload, ISession, IStartProps} from '../models/session'
-import {IConfigObj} from '../models/config'
-
-const Session: ISession = {
-  sessionStarted: false,
-  token: null,
-  config: null,
-  currentCohort: null,
-  initialize: async function () {
-    if (!this.sessionStarted) {
-      if (!this.config) {
-        throw InternalError('Configuration not found')
-      }
-
-      if (!fs.existsSync(this.config.dirPath)) {
-        fs.mkdirSync(this.config.dirPath)
-      }
-
-      await storage.init({dir: `${this.config.dirPath}/.session`})
-      this.sessionStarted = true
-    }
-
-    return true
-  },
-  setPayload: async function (value: IPayload) {
-    await this.initialize()
-    await storage.setItem('bc-payload', {token: this.token, ...value})
-    Console.debug('Payload successfuly found and set for ' + value.email)
-    return true
-  },
-  getPayload: async function () {
-    await this.initialize()
-    let payload = null
-    try {
-      payload = await storage.getItem('bc-payload')
-    } catch (error) {
-      // TODO: Remove it
-      console.log(error)
-      Console.debug('Error retriving session payload')
-    }
-
-    return payload
-  },
-  isActive: function () {
-    /* if (this.token) {
-      return true
-    } else {
-      return false
-    } */
-    return !!this.token
-  },
-  get: async function (configObj?: IConfigObj) {
-    if (configObj && configObj.config) {
-      this.config = configObj.config
-    }
-
-    await this.sync()
-    if (!this.isActive()) {
-      return null
-    }
-
-    const payload = await this.getPayload()
-
-    return {
-      payload,
-      token: this.token,
-    }
-  },
-  login: async function () {
-    const email = await cli.prompt('What is your email?')
-    if (!v.isEmail(email)) {
-      throw ValidationError('Invalid email')
-    }
-
-    const password = await cli.prompt('What is your password?', {
-      type: 'hide',
-    })
-
-    const data = await api.login(email, password)
-    if (data) {
-      this.start({token: data.token, payload: data})
-    }
-  },
-  sync: async function () {
-    const payload = await this.getPayload()
-    if (payload) {
-      this.token = payload.token
-    }
-  },
-  start: async function ({token, payload = null}: IStartProps) {
-    if (!token) {
-      throw new Error('A token and email is needed to start a session')
-    }
-
-    this.token = token
-
-    if (payload && (await this.setPayload(payload))) {
-      Console.success(`Successfully logged in as ${payload.email}`)
-    }
-  },
-  destroy: async function () {
-    await storage.clear()
-    this.token = null
-    Console.success('You have logged out')
-  },
-}
-
-export default Session
+import Console from "../utils/console"
+import api from "../utils/api"
+
+import v from "validator"
+import { ValidationError, InternalError } from "../utils/errors"
+
+import * as fs from "fs"
+import cli from "cli-ux"
+import * as storage from "node-persist"
+
+import { IPayload, ISession, IStartProps } from "../models/session"
+import { IConfigObj } from "../models/config"
+
+const Session: ISession = {
+  sessionStarted: false,
+  token: null,
+  config: null,
+  currentCohort: null,
+  initialize: async function () {
+    if (!this.sessionStarted) {
+      if (!this.config) {
+        throw InternalError("Configuration not found")
+      }
+
+      if (!fs.existsSync(this.config.dirPath)) {
+        fs.mkdirSync(this.config.dirPath)
+      }
+
+      await storage.init({ dir: `${this.config.dirPath}/.session` })
+      this.sessionStarted = true
+    }
+
+    return true
+  },
+  getOpenAIToken: async function () {
+    await this.initialize()
+    let token = null
+    try {
+      token = await storage.getItem("openai-token")
+    } catch {
+      Console.debug("Error retriving openai token")
+    }
+
+    return token
+  },
+  setOpenAIToken: async function (token: string) {
+    await this.initialize()
+    await storage.setItem("openai-token", token)
+    Console.debug("OpenAI token successfuly set")
+    return true
+  },
+  setPayload: async function (value: IPayload) {
+    await this.initialize()
+    await storage.setItem("bc-payload", { token: this.token, ...value })
+    Console.debug("Payload successfuly found and set for " + value.email)
+    return true
+  },
+  getPayload: async function () {
+    await this.initialize()
+    let payload = null
+    try {
+      payload = await storage.getItem("bc-payload")
+    } catch (error) {
+      // TODO: Remove it
+      console.log(error)
+      Console.debug("Error retriving session payload")
+    }
+
+    return payload
+  },
+  isActive: function () {
+    /* if (this.token) {
+      return true
+    } else {
+      return false
+    } */
+    return !!this.token
+  },
+  get: async function (configObj?: IConfigObj) {
+    if (configObj && configObj.config) {
+      this.config = configObj.config
+    }
+
+    await this.sync()
+    if (!this.isActive()) {
+      return null
+    }
+
+    const payload = await this.getPayload()
+
+    return {
+      payload,
+      token: this.token,
+    }
+  },
+  login: async function () {
+    const email = await cli.prompt("What is your email?")
+    if (!v.isEmail(email)) {
+      throw ValidationError("Invalid email")
+    }
+
+    const password = await cli.prompt("What is your password?", {
+      type: "hide",
+    })
+
+    const data = await api.login(email, password)
+    if (data) {
+      cli.log(data)
+      this.start({ token: data.token, payload: data })
+    }
+  },
+  loginWeb: async function (email, password) {
+    if (!v.isEmail(email)) {
+      throw ValidationError("Invalid email")
+    }
+
+    const data = await api.login(email, password)
+    if (data) {
+      this.start({ token: data.token, payload: data })
+      return data
+    }
+  },
+  sync: async function () {
+    const payload = await this.getPayload()
+    if (payload) {
+      this.token = payload.token
+    }
+  },
+  start: async function ({ token, payload = null }: IStartProps) {
+    if (!token) {
+      throw new Error("A token and email is needed to start a session")
+    }
+
+    this.token = token
+
+    if (payload && (await this.setPayload(payload))) {
+      Console.success(`Successfully logged in as ${payload.email}`)
+    }
+  },
+  destroy: async function () {
+    await storage.clear()
+    this.token = null
+    Console.success("You have logged out")
+  },
+}
+
+export default Session