@learnpack/learnpack 2.1.26 → 2.1.28

package/src/managers/socket.ts

@@ -1,20 +1,20 @@
-import {Socket, Server} from 'socket.io'
-import Console from '../utils/console'
-import queue from '../utils/fileQueue'
-
-import {ISocket, TPossibleActions} from '../models/socket'
-import {IConfig} from '../models/config'
-import {ICallback, TAction} from '../models/action'
-import {IExercise, IExerciseData} from '../models/exercise-obj'
-import {TStatus} from '../models/status'
-import {TSuccessType} from '../models/success-types'
-import * as http from 'http'
+import { Socket, Server } from "socket.io"
+import Console from "../utils/console"
+import queue from "../utils/fileQueue"
+
+import { ISocket, TPossibleActions } from "../models/socket"
+import { IConfig } from "../models/config"
+import { ICallback, TAction } from "../models/action"
+import { IExercise, IExerciseData } from "../models/exercise-obj"
+import { TStatus } from "../models/status"
+import { TSuccessType } from "../models/success-types"
+import * as http from "http"
 
 const SocketManager: ISocket = {
   socket: null,
   config: null,
   allowedActions: [],
-  possibleActions: ['build', 'reset', 'test', 'tutorial'],
+  possibleActions: ["build", "reset", "test", "tutorial"],
   isTestingEnvironment: false,
   actionCallBacks: {
     clean: (_, s: { logs: Array<string> }) => {
@@ -22,86 +22,91 @@ const SocketManager: ISocket = {
     },
   },
   addAllowed: function (actions: Array<TPossibleActions> | TPossibleActions) {
-    if (!Array.isArray(actions))
-      actions = [actions]
+    if (!Array.isArray(actions)) 
+actions = [actions]
 
     // avoid adding the "test" action if grading is disabled
     if (
-      actions.includes('test') &&
-      this.config?.disabledActions?.includes('test')
+      actions.includes("test") &&
+      this.config?.disabledActions?.includes("test")
     ) {
-      actions = actions.filter((a: TPossibleActions) => a !== 'test')
+      actions = actions.filter((a: TPossibleActions) => a !== "test")
     }
 
     this.allowedActions = [
       ...(this.allowedActions || []).filter(
-        (a: TPossibleActions) => !actions.includes(a),
+        (a: TPossibleActions) => !actions.includes(a)
       ),
       ...actions,
     ]
   },
   removeAllowed: function (
-    actions: Array<TPossibleActions> | TPossibleActions,
+    actions: Array<TPossibleActions> | TPossibleActions
   ) {
     if (!Array.isArray(actions)) {
       actions = [actions]
     }
 
     this.allowedActions = (this.allowedActions || []).filter(
-      (a: TPossibleActions) => !actions.includes(a),
+      (a: TPossibleActions) => !actions.includes(a)
     )
   },
   start: function (
     config: IConfig,
     server: http.Server,
-    isTestingEnvironment = false,
+    isTestingEnvironment = false
   ) {
     this.config = config
     this.isTestingEnvironment = isTestingEnvironment
+    this.socket = new Server(server, {
+      allowEIO3: true,
+      cors: {
+        origin: "http://localhost:5173",
+        methods: ["GET", "POST"],
+      },
+    })
 
-    this.socket = new Server(server, {allowEIO3: true})
+    this.allowedActions =
+      this.config?.disabledActions?.includes("test") ||
+      this.config?.disableGrading ?
+        this.possibleActions.filter(
+            a => !this.config?.disabledActions?.includes(a) && a !== "test"
+          ) :
+        this.possibleActions.filter(a => !this.allowedActions?.includes(a))
 
-    this.allowedActions = this.config?.disabledActions?.includes('test') ||
-      this.config?.disableGrading ? this.possibleActions.filter(
-        a => !this.config?.disabledActions?.includes(a) && a !== 'test',
-      ) : this.possibleActions.filter(
-        a => !this.allowedActions?.includes(a),
-      )
-
-    if (this.config?.grading === 'incremental') {
-      this.removeAllowed('reset')
+    if (this.config?.grading === "incremental") {
+      this.removeAllowed("reset")
     }
 
     if (this.socket) {
-      this.socket.on('connection', (socket: Socket) => {
+      this.socket.on("connection", (socket: Socket) => {
         Console.debug(
-          'Connection with client successfully established',
-          this.allowedActions,
+          "Connection with client successfully established",
+          this.allowedActions
         )
         if (!this.isTestingEnvironment) {
-          this.log('ready', ['Ready to compile or test...'])
+          this.log("ready", ["Ready to compile or test..."])
         }
 
         socket.on(
-          'compiler',
-          ({action, data}: { action: string; data: IExerciseData }) => {
-            this.emit('clean', 'pending', ['Working...'])
-
-            if (typeof data.exerciseSlug === 'undefined') {
-              this.log('internal-error', ['No exercise slug specified'])
-              Console.error('No exercise slug especified')
+          "compiler",
+          ({ action, data }: { action: string; data: IExerciseData }) => {
+            this.emit("clean", "pending", ["Working..."])
+            if (typeof data.exerciseSlug === "undefined") {
+              this.log("internal-error", ["No exercise slug specified"])
+              Console.error("No exercise slug especified")
               return
             }
 
             if (
               this.actionCallBacks &&
-              typeof this.actionCallBacks[action] === 'function'
+              typeof this.actionCallBacks[action] === "function"
             ) {
               this.actionCallBacks[action](data)
             } else {
-              this.log('internal-error', ['Uknown action ' + action])
+              this.log("internal-error", ["Uknown action " + action])
             }
-          },
+          }
         )
       })
     }
@@ -111,14 +116,18 @@ const SocketManager: ISocket = {
       this.actionCallBacks[action] = callBack
     }
   },
-  clean: function (_ = 'pending', logs = []) {
-    this.emit('clean', 'pending', logs)
+  clean: function (_ = "pending", logs = []) {
+    this.emit("clean", "pending", logs)
   },
   ask: function (questions = []) {
     return new Promise((resolve, _) => {
-      this.emit('ask', 'pending', ['Waiting for input...'], questions)
-      this.on('input', ({inputs}: any) => {
+      this.emit("ask", "pending", ["Waiting for input..."], questions)
+      console.log("Setting up listeners")
+      this.on("input", ({ inputs }: any) => {
         // Workaround to fix issue because null inputs
+
+        console.log("inputs", inputs)
+
         let isNull = false
         // eslint-disable-next-line
         inputs.forEach((input: any) => {
@@ -135,62 +144,62 @@ const SocketManager: ISocket = {
   },
   reload: function (
     files: Array<string> | null = null,
-    exercises: Array<string> | null = null,
+    exercises: Array<string> | null = null
   ) {
     this.emit(
-      'reload',
-      files?.join('') || '' /* TODO: Check it out this */,
-      exercises!,
+      "reload",
+      files?.join("") || "" /* TODO: Check it out this */,
+      exercises!
     )
   },
-  openWindow: function (url = '') {
+  openWindow: function (url = "") {
     queue.dispatcher().enqueue(queue.events.OPEN_WINDOW, url)
     this.emit(
       queue.events.OPEN_WINDOW as TAction,
-      'ready',
+      "ready",
       [`Opening ${url}`],
       [],
       [],
-      url,
+      url
     )
   },
   log: function (
     status: TStatus,
     messages: string | Array<string> = [],
     report: Array<string> = [],
-    data: any = null,
+    data: any = null
   ) {
-    this.emit('log', status, messages, [], report, data)
+    this.emit("log", status, messages, [], report, data)
     Console.log(messages)
   },
   emit: function (
     action: TAction,
-    status: TStatus | string = 'ready',
+    status: TStatus | string = "ready",
     logs: string | Array<string> = [],
     inputs: Array<string> = [],
     report: Array<string> = [],
-    data: any = null,
+    data: any = null
   ) {
     if (
       this.config?.compiler &&
-      ['webpack', 'vanillajs', 'vue', 'react', 'css', 'html'].includes(
-        this.config?.compiler,
+      ["webpack", "vanillajs", "vue", "react", "css", "html"].includes(
+        this.config?.compiler
       )
     ) {
-      if (['compiler-success', 'compiler-warning'].includes(status))
-        this.addAllowed('preview')
-      if (['compiler-error'].includes(status) || action === 'ready')
-        this.removeAllowed('preview')
+      if (["compiler-success", "compiler-warning"].includes(status))
+        this.addAllowed("preview")
+      if (["compiler-error"].includes(status) || action === "ready")
+        this.removeAllowed("preview")
     }
 
-    if (this.config?.grading === 'incremental') {
-      this.removeAllowed('reset')
+    if (this.config?.grading === "incremental") {
+      this.removeAllowed("reset")
     }
 
     // eslint-disable-next-line
     this.config?.disabledActions?.forEach((a) => this.removeAllowed(a));
 
-    this.socket?.emit('compiler', {
+    this.socket?.emit("compiler", {
       action,
       status,
       logs,
@@ -202,31 +211,35 @@ const SocketManager: ISocket = {
   },
 
   ready: function (message: string) {
-    this.log('ready', [message])
+    this.log("ready", [message])
   },
   success: function (type: TSuccessType, stdout: string) {
-    const types = ['compiler', 'testing']
+    const types = ["compiler", "testing"]
     if (!types.includes(type))
       this.fatal(`Invalid socket success type "${type}" on socket`)
-    else if (stdout === '')
-      this.log((type + '-success') as TSuccessType, [
-        'No stdout to display on the console',
+    else if (stdout === "")
+      this.log((type + "-success") as TSuccessType, [
+        "No stdout to display on the console",
       ])
-    else
-      this.log((type + '-success') as TSuccessType, [stdout])
+    else 
+this.log((type + "-success") as TSuccessType, [stdout])
   },
   error: function (type: TStatus, stdout: string) {
-    console.error('Socket error: ' + type, stdout)
+    console.error("Socket error: " + type, stdout)
     this.log(type, [stdout])
 
     if (this.isTestingEnvironment) {
       this.onTestingFinished({
-        result: 'failed',
+        result: "failed",
       })
     }
   },
+  complete: function () {
+    console.log("complete")
+  },
+
   fatal: function (msg: string) {
-    this.log('internal-error', [msg])
+    this.log("internal-error", [msg])
     throw msg
   },
   onTestingFinished: function (result: any) {

package/src/models/action.ts

@@ -1,3 +1,10 @@
-export type TAction = 'test' | 'log' | 'reload' | 'ready' | 'clean' | 'ask';
+export type TAction =
+  | "test"
+  | "log"
+  | "reload"
+  | "ready"
+  | "clean"
+  | "ask"
+  | "generation";
 
 export type ICallback = (...agrs: any[]) => any;

package/src/models/config-manager.ts

@@ -1,5 +1,5 @@
-import { IConfigObj, TGrading } from "./config";
-import { IExercise } from "./exercise-obj";
+import { IConfigObj, TGrading } from "./config"
+import { IExercise } from "./exercise-obj"
 
 export interface IConfigManagerAttributes {
   grading: TGrading;

package/src/models/config.ts

@@ -1,10 +1,15 @@
-import { IExercise } from "./exercise-obj";
+import { IExercise } from "./exercise-obj"
 
 export type TGrading = "isolated" | "incremental" | "no-grading";
 
 export type TMode = "preview" | "standalone";
 
-export type TConfigAction = "test" | "build" | "tutorial" | "reset";
+export type TConfigAction =
+  | "test"
+  | "build"
+  | "tutorial"
+  | "reset"
+  | "generate";
 
 export type TConfigObjAttributes = "config" | "exercises" | "grading";
 

package/src/models/exercise-obj.ts

@@ -1,6 +1,6 @@
-import { IFile } from "./file";
-import { IConfig } from "./config";
-import { ISocket } from "./socket";
+import { IFile } from "./file"
+import { IConfig } from "./config"
+import { ISocket } from "./socket"
 
 export interface IExercise {
   position?: number;
@@ -21,6 +21,9 @@ export interface IExercise {
 }
 
 export interface IExerciseData {
+  lastMessages?: any;
+  userMessage?: string;
   exerciseSlug: string;
+  entryPoint?: string;
   files: string[];
 }

package/src/models/plugin-config.ts

@@ -1,5 +1,5 @@
-import { IConfig } from "./config";
-import { IExercise } from "./exercise-obj";
+import { IConfig } from "./config"
+import { IExercise } from "./exercise-obj"
 
 export interface IPluginConfig {
   language: string;

package/src/models/session.ts

@@ -1,4 +1,4 @@
-import {IConfig, IConfigObj} from './config'
+import { IConfig, IConfigObj } from "./config"
 
 export interface IPayload {
   email: string;
@@ -15,12 +15,15 @@ export interface ISession {
   config: IConfig | null;
   currentCohort: null;
   initialize: () => Promise<boolean>;
+  getOpenAIToken: () => Promise<string | null>;
+  setOpenAIToken: (token: string) => Promise<boolean>;
   setPayload: (value: IPayload) => Promise<boolean>;
   getPayload: () => Promise<any>;
   isActive: () => boolean;
   get: (config?: IConfigObj) => Promise<any>;
   login: () => Promise<void>;
+  loginWeb: (email: string, password: string) => Promise<void>;
   sync: () => Promise<void>;
-  start: ({token, payload}: IStartProps) => Promise<void>;
+  start: ({ token, payload }: IStartProps) => Promise<void>;
   destroy: () => Promise<void>;
 }

package/src/models/socket.ts

@@ -1,10 +1,15 @@
-import {IConfig} from './config'
-import {Server} from 'socket.io'
-import {DefaultEventsMap} from 'socket.io/dist/typed-events'
-import {TAction, ICallback} from './action'
-import {TStatus} from './status'
+import { IConfig } from "./config"
+import { Server } from "socket.io"
+import { DefaultEventsMap } from "socket.io/dist/typed-events"
+import { TAction, ICallback } from "./action"
+import { TStatus } from "./status"
 
-export type TPossibleActions = 'build' | 'test' | 'reset' | 'tutorial';
+export type TPossibleActions =
+  | "build"
+  | "test"
+  | "reset"
+  | "tutorial"
+  | "generate";
 
 export interface ISocket {
   socket: Server<
@@ -23,6 +28,7 @@ export interface ISocket {
   start: (config: IConfig, server: any, isTestingEnvironment: boolean) => void;
   on: (action: any, callBack: any) => void;
   clean: (_: string, logs: Array<any>) => void;
+  complete: () => void;
   ask: (questions: Array<string>) => void;
   reload: (files: Array<string> | null, exercises: Array<string>) => void;
   openWindow: (id: string) => void;

package/src/models/status.ts

@@ -1,15 +1,16 @@
 export type TStatus =
-  | 'ready'
-  | 'internal-error'
-  | 'compiler-success'
-  | 'testing-success'
-  | 'compiling'
-  | 'testing'
-  | 'start_exercise'
-  | 'initializing'
-  | 'configuration_loaded'
-  | 'connection_ended'
-  | 'reset_exercise'
-  | 'open_files'
-  | 'open_window'
-  | 'instructions_closed';
+  | "ready"
+  | "internal-error"
+  | "compiler-success"
+  | "testing-success"
+  | "compiling"
+  | "testing"
+  | "start_exercise"
+  | "initializing"
+  | "configuration_loaded"
+  | "connection_ended"
+  | "reset_exercise"
+  | "open_files"
+  | "open_window"
+  | "instructions_closed"
+  | "completed";

package/src/plugin/command/compile.ts

@@ -1,17 +1,17 @@
-import { IError } from "../../models/errors";
+import { IError } from "../../models/errors"
 
 const CompilationError = (messages: string) => {
-  const _err: IError = new Error(messages);
-  _err.status = 400;
-  _err.stdout = messages;
-  _err.type = "compiler-error";
-  return _err;
-};
+  const _err: IError = new Error(messages)
+  _err.status = 400
+  _err.stdout = messages
+  _err.type = "compiler-error"
+  return _err
+}
 
 export default {
   CompilationError,
   default: async ({ action, ...rest }: any) => {
-    const stdout = await action.run(rest);
-    return stdout;
+    const stdout = await action.run(rest)
+    return stdout
   },
-};
+}

package/src/plugin/command/test.ts

@@ -1,30 +1,30 @@
-import * as fs from "fs";
-import { IError } from "../../models/errors";
+import * as fs from "fs"
+import { IError } from "../../models/errors"
 
 const TestingError = (messages: string) => {
-  const _err: IError = new Error(messages);
-  _err.status = 400;
-  _err.stdout = messages;
-  _err.type = "testing-error";
-  return _err;
-};
+  const _err: IError = new Error(messages)
+  _err.status = 400
+  _err.stdout = messages
+  _err.type = "testing-error"
+  return _err
+}
 
 export default {
   TestingError,
   default: async function (args: any) {
-    const { action, configuration, socket, exercise } = args;
+    const { action, configuration, socket, exercise } = args
 
     if (!fs.existsSync(`${configuration.dirPath}/reports`)) {
       // reports directory
-      fs.mkdirSync(`${configuration.dirPath}/reports`);
+      fs.mkdirSync(`${configuration.dirPath}/reports`)
     }
 
     // compile
-    const stdout = await action.run(args);
+    const stdout = await action.run(args)
 
     // mark exercise as done
-    exercise.done = true;
+    exercise.done = true
 
-    return stdout;
+    return stdout
   },
-};
+}

package/src/plugin/index.ts

@@ -1,6 +1,6 @@
-import CompilationError from "./command/compile";
-import TestingError from "./command/test";
-import utils from "./utils";
-import plugin from "./plugin";
+import CompilationError from "./command/compile"
+import TestingError from "./command/test"
+import utils from "./utils"
+import plugin from "./plugin"
 
-export default { CompilationError, TestingError, Utils: utils, plugin };
+export default { CompilationError, TestingError, Utils: utils, plugin }