diff --git a/frontend/electron/main/index.ts b/frontend/electron/main/index.ts
index fe5cb72e..f3ff41c1 100644
--- a/frontend/electron/main/index.ts
+++ b/frontend/electron/main/index.ts
@@ -7,7 +7,7 @@ import { release } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import "../../polyfill/crypto";
-import { startExpressServer } from "../../server/express.mjs";
+import { gracefullyStopAnvil, startExpressServer } from "../../server/express.mjs";
 import { update } from './update';
 import sourcemap from 'source-map-support';
 
@@ -44,6 +44,16 @@ if (targetIndex !== -1) {
   process.env.VITE_ZETAFORGE_IS_DEV = 'False'
 }
 
+const isPip = '--is_pip'
+
+const targetPipIndex = process.argv.indexOf(isPip)
+
+if(targetPipIndex !== -1) {
+  process.env.VITE_IS_PIP = 'True'
+} else {
+  process.env.VITE_IS_PIP = 'False'
+}
+
 // Disable GPU Acceleration for Windows 7
 if (release().startsWith('6.1')) app.disableHardwareAcceleration()
 
@@ -66,6 +76,7 @@ const preload = join(__dirname, '../preload/index.mjs')
 const url = process.env.VITE_DEV_SERVER_URL
 const indexHtml = join(process.env.DIST, 'index.html')
 
+
 const isMac = process.platform === 'darwin'
 const menuTemplate: Electron.MenuItemConstructorOptions[] = [
   ...(isMac? 
@@ -161,10 +172,16 @@ async function createWindow() {
 app.whenReady().then(createWindow)
 
 app.on('window-all-closed', () => {
+  console.log("WINDOW ALL CLOSED!!!!")
   win = null
   if (process.platform !== 'darwin') app.quit()
 })
 
+app.on('will-quit', () => {
+  console.log("QUITTING ANVIL...")
+  gracefullyStopAnvil()
+})
+
 app.on('second-instance', () => {
   if (win) {
     // Focus on the main window if the user tried to open another
@@ -177,8 +194,10 @@ app.on('activate', () => {
   const allWindows = BrowserWindow.getAllWindows()
   if (allWindows.length) {
     allWindows[0].focus()
+    allWindows[0].webContents.send('missing-config')
   } else {
     createWindow()
+    win?.webContents.send('missing-config')
   }
 })
 
diff --git a/frontend/server/express.mjs b/frontend/server/express.mjs
index d2dca90c..e65d1418 100644
--- a/frontend/server/express.mjs
+++ b/frontend/server/express.mjs
@@ -1,5 +1,5 @@
 import bodyParser from "body-parser";
-import { spawn } from "child_process";
+import { spawn, exec } from "child_process";
 import compression from "compression";
 import cors from "cors";
 import "dotenv/config";
@@ -12,14 +12,30 @@ import path from "path";
 import sha256 from "sha256";
 import getMAC from "getmac";
 import { BLOCK_SPECS_FILE_NAME } from "../src/utils/constants";
+import axios from "axios"
+
+let anvilProcess = null
+
+
+function gracefullyStopAnvil() {
+  if(anvilProcess !== null) {
+    anvilProcess.kill("SIGINT")
+    const sleep = new Promise(((resolve) => setTimeout(resolve, 5000)))
+    sleep().then(res => {
+      console.log("schleepy shleep")
+    })
+  }
+}
 
 function startExpressServer() {
   const app = express();
   const port = 3330;
-
-  app.use(cors());
+  
+  app.use(cors({
+    origin: '*'
+  }))
   app.use(compression());
-
+  
   // http://expressjs.com/en/advanced/best-practice-security.html#at-a-minimum-disable-x-powered-by-header
   app.disable("x-powered-by");
   //app.use(express.static(path.join(__dirname, '..', '..', 'backup_frontend')));
@@ -35,6 +51,7 @@ function startExpressServer() {
   app.use(express.static("public"));
   app.use(bodyParser.json());
 
+
   // OpenAI
   const configuration = new Configuration({
     apiKey: process.env.OPENAI_API_KEY,
@@ -165,6 +182,31 @@ function startExpressServer() {
     });
   });
 
+  app.get("/get-kube-contexts", async (req, res) => {
+    async function getKubectlContexts() {
+      return new Promise((resolve, reject) => {
+        exec('kubectl config get-contexts -o name', (error, stdout, stderr) => {
+          if (error) {
+            return reject(`Error executing kubectl command: ${error.message}`);
+          }
+          if (stderr) {
+            return reject(`Error in kubectl command output: ${stderr}`);
+          }
+          // Split the output into an array of contexts
+          const contexts = stdout.trim().split('\n');
+          resolve(contexts);
+        });
+      });
+    }
+    try {
+      const contexts = await getKubectlContexts()
+      res.status(200).json(contexts)
+    } catch(err) {
+      console.log(err)
+      res.sendStatus(500)
+    }
+  })
+
   app.post("/api/call-agent", async (req, res) => {
     const { userMessage, agentName, conversationHistory, apiKey } = req.body;
     console.log("USER MESSAGE", userMessage);
@@ -229,6 +271,499 @@ function startExpressServer() {
       res.status(500).send({ error: "Error reading directory" });
     }
   });
+  
+  app.get("/get-anvil-config", (req, res) => {
+    if(!electronApp.isPackaged) {
+      const response = {has_config: false}
+      res.status(200).send(response)
+    }
+    const anvilDir = path.join(process.resourcesPath, 'server2')
+    const anvilFiles = fs.readdirSync(anvilDir)
+    if(anvilFiles.includes('config.json')) {
+      const configFile = path.join(anvilDir, 'config.json')
+      const configStr = fs.readFileSync(configFile)
+      const config = JSON.parse(configStr)
+      const response = {
+        has_config: true,
+        config: config
+      }
+      res.status(200).send(response)
+    } else {
+      const response = {has_config: false}
+      res.status(200).send(response)
+    }
+  })
+
+  app.post("/launch-anvil-from-config", (req, res) => {
+    const anvilTimeoutPromise = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject(new Error("Anvil Timeout Error"))
+      }, 3 * 60 * 1000)
+    })
+    if(anvilProcess !== null) {
+      anvilProcess.kill("SIGINT")
+      anvilProcess = null
+      console.log("killed the process")
+    }
+    const anvilDir = path.join(process.resourcesPath, 'server2')
+    const configPath = path.join(anvilDir, 'config.json')
+    const configStr = fs.readFileSync(configPath)
+    const config = JSON.parse(configStr)
+    
+    const context = config.KubeContext
+    const kubeConfig = ['config', 'use-context', context]
+    const kubeExec = spawn('kubectl', kubeConfig)
+
+    kubeExec.stderr.on('data', (data) => {
+      console.log(`stderr: ${data}`)
+      res.status(500).send({err: "CAN'T SET KUBECONTEXT", kubeErr: data.toString()})
+    })
+
+    const anvilFiles = fs.readdirSync(anvilDir)
+    const anvilExec = anvilFiles.filter((file) => file.startsWith('s2-'))[0]
+    const runAnvil = new Promise((resolve, reject) => {
+      anvilProcess = spawn(path.join(anvilDir, anvilExec), {
+        cwd: anvilDir,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'], // Ignore stdin, use pipes for stdout and stderr
+      });
+
+      anvilProcess.stdout.on('data', (data) => {
+          console.log(`[server] stdout: ${data}`);
+          
+          if(data.toString().includes('[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.')){
+            console.log("ANVIL RUN SUCCESFULLY")
+            resolve()
+          }
+        });
+          
+      anvilProcess.stderr.on('data', (data) => {
+          console.log(`[server] stderr: ${data}`);
+          if( data.toString().includes("Failed to fetch kubernetes resources;") || data.toString().includes("Failed to get client config;") || data.toString().includes("Failed to install argo;")) {
+            console.log("I AM REJECTING NOWWWWWW")
+            reject(new Error(`Kubeservices not found: ${data.toString()}`))
+          }
+        });
+          
+      anvilProcess.on('close', (code) => {});
+
+    })
+    console.log("CHECK RES2")
+    console.log(res)
+
+    const runAnvilPromise = Promise.race([anvilTimeoutPromise, runAnvil])
+
+    runAnvilPromise.then((response) => {
+      res.sendStatus(200)
+    }).catch(err => {
+      res.status(500).send({err: "Error while launching anvil" , kubeErr: err.message})
+    })
+  })
+
+
+  app.post("/launch-anvil", (req, res) => {
+
+
+    const anvilTimeoutPromise = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject(new Error("Anvil Timeout Error"))
+      }, 3 * 60 * 1000)
+    })
+
+
+    if(!electronApp.isPackaged) {
+      res.sendStatus(200)
+    }
+    if(anvilProcess !== null) {
+      anvilProcess.kill("SIGINT")
+      anvilProcess = null
+      console.log("killed the process")
+    }
+    console.log("CAN I REACH HERE AFTER KILL???")
+
+    const anvilDir = path.join(process.resourcesPath, 'server2')
+    const body = req.body
+
+    const config = {
+      IsLocal: true,
+      IsDev: true? process.env.VITE_ZETAFORGE_IS_DEV === 'True': false ,
+      ServerPort: parseInt(body.anvilPort),
+      KanikoImage: "gcr.io/kaniko-project/executor:latest",
+      WorkDir: "/app",
+      FileDir: "/files",
+      ComputationFile: "computations.py",
+      EntrypointFile: "entrypoint.py",
+      ServiceAccount: "executor",
+      Bucket: "forge-bucket",
+      Database: "./zetaforge.db",
+      KubeContext: body.KubeContext,
+      SetupVersion: "1",
+      Local: {
+        BucketPort: parseInt(body.s3Port),
+        Driver: body.driver
+      }      
+    }
+    const configDir = path.join(anvilDir, 'config.json')
+    const configStr = JSON.stringify(config)
+    try{
+      fs.writeFileSync(configDir, configStr)
+      console.log("FILE WRITTEN")
+    } catch(err) {
+      console.log("ERROR HAPPEND WHILE WRITING CONFIG.JS")
+      console.log(err)
+      res.status(500).send("Error happend while writing config.js")
+    }
+    const kubeConfig = ['config', 'use-context', body.KubeContext]
+    const kubeExec = spawn('kubectl', kubeConfig)
+    kubeExec.stderr.on('data', (data) => {
+      console.log(`stderr: ${data}`)
+      res.status(500).send({err: "CAN'T SET KUBECONTEXT", kubeErr: data.toString()})
+    })
+    const anvilFiles = fs.readdirSync(anvilDir)
+
+    const anvilExec = anvilFiles.filter((file) => file.startsWith('s2-'))[0]
+    const runAnvil = new Promise((resolve, reject) => {
+      anvilProcess = spawn(path.join(anvilDir, anvilExec), {
+        cwd: anvilDir,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'], // Ignore stdin, use pipes for stdout and stderr
+      });
+
+      anvilProcess.stdout.on('data', (data) => {
+          console.log(`[server] stdout: ${data}`);
+          
+          if(data.toString().includes('[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.')){
+            console.log("ANVIL RUN SUCCESFULLY")
+            resolve()
+          }
+        });
+          
+      anvilProcess.stderr.on('data', (data) => {
+          console.log(`[server] stderr: ${data}`);
+          if( data.toString().includes("Failed to fetch kubernetes resources;") || data.toString().includes("Failed to get client config;") || data.toString().includes("Failed to install argo;")) {
+            console.log("I AM REJECTING NOWWWWWW")
+            reject(new Error(`Kubeservices not found: ${data.toString()}`))
+          }
+        });
+          
+      anvilProcess.on('close', (code) => {});
+
+    })
+    
+
+    const runAnvilPromise = Promise.race([anvilTimeoutPromise, runAnvil])
+
+    runAnvilPromise.then((response) => {
+      res.sendStatus(200)
+    }).catch(err => {
+      res.status(500).send({err: "Error while launching anvil" , kubeErr: err.message})
+    })
+  })
+
+
+  app.post("/initial-anvil-launch", (req, res) => {
+    console.log("INITIAL LAUNCH")
+    if(!electronApp.isPackaged) {
+      res.sendStatus(200)
+    }
+    const anvilDir = path.join(process.resourcesPath, 'server2')
+    try{
+      const anvilFiles = fs.readdirSync(anvilDir)
+      if(!anvilFiles.includes('config.json')) {
+        console.log("CONFIG NOT FOUND")
+        res.status(500).send({error: "CONFIG NOT FOUND"})
+      } else {
+        console.log("CONFIG FOUND")
+        const configFile = path.join(anvilDir, 'config.json')
+        const configBuffer = fs.readFileSync(configFile)
+        const config = JSON.parse(configBuffer)
+        if(config.IsLocal !== true){
+          res.status(500).send({err: "Malformed config.json", kubeErr: "Local must be true"})
+        }
+        if(config.Local.Driver === 'minikube') {
+          console.log("DRIVER IS MINIKUBE#######")
+          const kubeConfig = ['config', 'use-context', 'zetaforge']
+          const kubeExec = spawn('kubectl', kubeConfig)
+          kubeExec.stderr.on('data', (data) => {
+            console.log(`stderr: ${data}`)
+            res.status(500).send({err: "CAN'T SET KUBECONTEXT", kubeErr: data.toString()})
+          })
+
+          const anvilExec = anvilFiles.filter((file) => file.startsWith('s2-'))[0]
+          const runAnvil = new Promise((resolve, reject) => {
+            anvilProcess = spawn(path.join(anvilDir, anvilExec), {
+              cwd: anvilDir,
+              detached: true,
+              stdio: ['ignore', 'pipe', 'pipe'], // Ignore stdin, use pipes for stdout and stderr
+            });
+      
+            anvilProcess.stdout.on('data', (data) => {
+                console.log(`[server] stdout: ${data}`);
+                
+                if(data.toString().includes('[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.')){
+                  console.log("ANVIL RUN SUCCESFULLY")
+                  resolve()
+                }
+              });
+                
+            anvilProcess.stderr.on('data', (data) => {
+                console.log(`[server] stderr: ${data}`);
+                if( data.toString().includes("Failed to fetch kubernetes resources;") || data.toString().includes("Failed to get client config;")) {
+                  reject(new Error(`Kubeservices not found: ${data.toString()}`))
+                }
+              });
+                
+            anvilProcess.on('close', (code) => {});
+
+          })
+          console.log("CHECK RES2")
+          console.log(res)
+
+          const runAnvilPromise = Promise.race([anvilTimeoutPromise, runAnvil])
+
+          runAnvilPromise.then((response) => {
+            res.sendStatus(200)
+          }).catch(err => {
+            res.status(500).send({err: "Error while launching anvil" , kubeErr: err.message})
+          })
+        } else {
+          console.log("CHECK KUBECONFIG")
+          console.log(config.KubeContext)
+          const kubeConfig = ['config', 'use-context', config.KubeContext]
+          const kubeExec = spawn('kubectl', kubeConfig)
+          kubeExec.stderr.on('data', (data) => {
+            console.log(`stderr: ${data}`)
+            res.status(500).send({err: "CAN'T SET KUBECONTEXT", kubeErr: data.toString()})
+          })
+          const anvilExec = anvilFiles.filter((file) => file.startsWith('s2-'))[0]
+          const runAnvil = new Promise((resolve, reject) => {
+            anvilProcess = spawn(path.join(anvilDir, anvilExec), {
+              cwd: anvilDir,
+              detached: true,
+              stdio: ['ignore', 'pipe', 'pipe'], // Ignore stdin, use pipes for stdout and stderr
+            });
+      
+            anvilProcess.stdout.on('data', (data) => {
+                console.log(`[server] stdout: ${data}`);
+                
+                if(data.toString().includes('[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.')){
+                  console.log("ANVIL RUN SUCCESFULLY")
+                  resolve()
+                }
+              });
+                
+            anvilProcess.stderr.on('data', (data) => {
+                console.log(`[server] stderr: ${data}`);
+                if(data.toString().includes("Failed to fetch kubernetes resources;")|| data.toString().includes("Failed to get client config;")) {
+                  reject(new Error(`Kubeservices not found: ${data.toString()}`))
+                }
+              });
+                
+            anvilProcess.on('close', (code) => {});
+
+          })
+          console.log("CHECK RES2")
+          console.log(res)
+
+          const runAnvilPromise = Promise.race([anvilTimeoutPromise, runAnvil])
+
+          runAnvilPromise.then((response) => {
+            res.sendStatus(200)
+          }).catch(err => {
+            res.status(500).send({err: "Error while launching anvil" , kubeErr: err.message})
+          })
+
+        }
+
+
+      }
+    } catch(err) {
+      res.sendStatus(500)
+    }
+  })
+
+
+  app.post("/create-anvil-config", (req, res) => {
+    console.log("CREATING ANVIL CONFIG")
+    const body = req.body
+    const config = {
+      IsLocal: true,
+      IsDev: true? process.env.VITE_ZETAFORGE_IS_DEV === 'True': false ,
+      ServerPort: parseInt(body.anvilPort),
+      KanikoImage: "gcr.io/kaniko-project/executor:latest",
+      WorkDir: "/app",
+      FileDir: "/files",
+      ComputationFile: "computations.py",
+      EntrypointFile: "entrypoint.py",
+      ServiceAccount: "executor",
+      Bucket: "forge-bucket",
+      Database: "./zetaforge.db",
+      KubeContext: body.KubeContext,
+      SetupVersion: "1",
+      Local: {
+        BucketPort: parseInt(body.s3Port),
+        Driver: body.KubeContext
+      }      
+    }
+    const anvilDir = path.join(process.resourcesPath, 'server2')
+    const configDir = path.join(anvilDir, 'config.json')
+    const configStr = JSON.stringify(config)
+    try{
+      fs.writeFileSync(configDir, configStr)
+      console.log("FILE WRITTEN")
+    } catch(err) {
+      console.log("ERROR HAPPEND WHILE WRITING CONFIG.JS")
+      console.log(err)
+    }
+    const kubectl = ['config', 'use-context', body.KubeContext]
+    const kubectlCmd = spawn('kubectl', kubectl)
+    kubectlCmd.on('error', (data) => {
+      console.log(data)
+      return res.status(500).send({err: "CAN'T SET KUBECONTEXT", kubeErr: data.toString()})
+    })
+
+    res.sendStatus(200)
+
+
+
+  })
+  
+  app.get("/isPackaged", (req, res) => {
+    console.log("INITIAL CHECK")
+    console.log(electronApp.isPackaged)
+    console.log("CHEEEEEEEEEEEEEEEEECCCKKK")
+    const isPip = process.env.VITE_IS_PIP === 'True'? true : false
+    return res.status(200).json(electronApp.isPackaged && !isPip)
+  })
+  // app.post("/launch-anvil", async (req,res) => {
+  //   if(!electronApp.isPackaged) {
+  //     res.sendStatus(200)
+  //   }
+  //   const anvilDir = path.join(process.resourcesPath, 'server2')
+  //   if(anvilProcess !== null) {
+  //     anvilProcess.kill()
+  //   }
+  //   const body = req.body
+
+    
+  //   const anvilFiles = fs.readdirSync(anvilDir)
+  //   if(!anvilFiles.includes('config.json')) {
+  //     console.log("CHECK DEV")
+  //     console.log(process.env.VITE_ZETAFORGE_IS_DEV)
+  //     const config = {
+  //       IsLocal: true,
+  //       IsDev: true? process.env.VITE_ZETAFORGE_IS_DEV === 'True': false,
+  //       ServerPort: parseInt(body.anvilPort),
+  //       KanikoImage: "gcr.io/kaniko-project/executor:latest",
+  //       WorkDir: "/app",
+  //       FileDir: "/files",
+  //       ComputationFile: "computations.py",
+  //       EntrypointFile: "entrypoint.py",
+  //       ServiceAccount: "executor",
+  //       Bucket: "forge-bucket",
+  //       Database: "./zetaforge.db",
+  //       KubeContext: body.KubeContext,
+  //       SetupVersion: "1",
+  //       Local: {
+  //         BucketPort: parseInt(body.s3Port),
+  //         Driver: body.KubeContext
+  //       }      
+  //     }
+
+  //     const configDir = path.join(anvilDir, 'config.json')
+  //     const configStr = JSON.stringify(config)
+  //     try{
+  //       fs.writeFileSync(configDir, configStr)
+  //       console.log("FILE WRITTEN")
+  //     } catch(err) {
+  //       console.log("ERROR HAPPEND WHILE WRITING CONFIG.JS")
+  //       res.status(500).status({err: "Config error happened", kubeErr: "Error creating config error"})
+
+  //       console.log(err)
+  //     }
+
+  //   } else {
+  //     console.log("EXCEPTION HAPPEN HERE")
+  //     //this else is added for minikube case.
+  //     const configDir = path.join(anvilDir, 'config.json')
+  //     const configFile = fs.readFileSync(configDir)
+  //     const config = JSON.parse(configFile)
+  //     config.KubeContext = body.KubeContext
+  //     if(config.Local.Driver !== 'minikube') {
+  //       config.Local.Driver = config.KubeContext
+  //     } else {
+  //       config.Local.Driver = 'minikube'
+  //     }
+
+  //     const configStr = JSON.stringify(config)
+  //     try {
+  //       fs.writeFileSync(configDir, configStr)
+  //     } catch(err) {
+  //       res.status(500).status({err: "Config error happened", kubeErr: "Error creating config error"})
+  //     }
+
+  //   }
+
+  //    const configDir = path.join(anvilDir, 'config.json')
+  //    const configBuffer = fs.readFileSync(configDir)
+  //    const config = JSON.parse(configBuffer)
+  //    if(config.Local.Driver === 'minikube') {
+  //     console.log("DRIVER IS MINIKUBE111")
+  //     const kubectl = ['config', 'use-context', 'zetaforge']
+  //     const kubectlCmd = spawn('kubectl', kubectl)
+  //     kubectlCmd.on('error', (data) => {
+  //       console.log(data)
+  //       return res.status(500).send({err: "CAN'T SET KUBECONTEXT", kubeErr: data.toString()})
+  //     })
+  //    } else {
+  //     console.log("CHECK HERE")
+  //     console.log(config.KubeContext)
+  //     const KubeContext = config.KubeContext
+  //     const kubectl = ['config', 'use-context', KubeContext]
+  //     const kubectlCmd = spawn('kubectl', kubectl)
+  //     kubectlCmd.on('error', (data) => {
+  //       console.log(data)
+  //       res.status(500).send({err: "CAN'T SET KUBECONTEXT", kubeErr: data.toString()})
+  //     })
+  //    }
+  //    const anvilDirContent = fs.readdirSync(anvilDir)
+  //    const anvilExec = anvilDirContent.filter((file) => file.startsWith('s2-'))[0]
+  //    console.log("STARTING LAUNCH ANVIL...")
+  //    const runAnvil = new Promise((resolve, reject) => {
+  //       anvilProcess = spawn(path.join(anvilDir, anvilExec), {
+  //         cwd: anvilDir,
+  //         detached: true,
+  //         stdio: ['ignore', 'pipe', 'pipe'], // Ignore stdin, use pipes for stdout and stderr
+  //       });
+  
+  //       anvilProcess.stdout.on('data', (data) => {
+  //           console.log(`[server] stdout: ${data}`);
+            
+  //           if(data.toString().includes('[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.')){
+  //             console.log("ANVIL RUN SUCCESFULLY")
+  //             resolve()
+  //           }
+  //         });
+            
+  //       anvilProcess.stderr.on('data', (data) => {
+  //           console.log(`[server] stderr: ${data}`);
+  //           if(data.toString().includes("Failed to fetch kubernetes resources;"|| data.toString().includes("Failed to get client config;"))){
+  //             reject(new Error(`Kubeservices not found: ${data.toString()}`))
+  //           }
+  //         });
+            
+  //       anvilProcess.on('close', (code) => {});
+
+  //     })
+  //     const runAnvilPromise = Promise.race([anvilTimeoutPromise, runAnvil])
+
+  //     runAnvilPromise.then((response) => {
+  //       res.sendStatus(200)
+  //     }).catch(err => {
+  //       res.status(500).send({err: "Error while launching anvil" , kubeErr: err.message})
+  //     })
+
+// })
 
   const getFileSystemContent = (dirPath) => {
     const fileSystem = {};
@@ -280,6 +815,13 @@ function startExpressServer() {
 
     return fileSystem;
   };
+  
+  app.post("/launch-anvil-locally", (req, res) => {
+    console.log("RECEIVED REQUEST")
+    const config = req.body
+
+    console.log(config)
+  })
 
   app.post("/new-block-react", (req, res) => {
     const data = req.body;
@@ -319,6 +861,23 @@ function startExpressServer() {
   app.listen(port, () => {
     console.log(`Server running at http://localhost:${port}`);
   });
+
+  process.on('SIGINT', () => {
+    console.log("SIGINT ANVIL")
+    if(anvilProcess !== null) {
+      console.log("KILLING ANVIL...")
+      anvilProcess.kill('SIGINT')
+    }
+  })
+
+  process.on('SIGTERM', () => {
+    console.log("SIGINT ANVIL")
+    if(anvilProcess !== null) {
+      console.log("KILLING ANVIL...")
+      anvilProcess.kill("SIGINT")
+    }
+
+  })
 }
 
-export { startExpressServer };
+export { startExpressServer, gracefullyStopAnvil };
diff --git a/frontend/server/s3.js b/frontend/server/s3.js
index c3d5e740..ad5d2e2b 100644
--- a/frontend/server/s3.js
+++ b/frontend/server/s3.js
@@ -57,6 +57,35 @@ async function copy(newKey, copyKey, anvilConfiguration) {
   }
 }
 
+export async function checkAndCopy(newKey, copyKey, anvilConfiguration) {
+  const oldExists = await fileExists(copyKey, anvilConfiguration)
+  if (!oldExists) {
+    throw new Error("Previous file did not upload successfully, please upload a new file.")
+  }
+  const exists = await fileExists(newKey, anvilConfiguration);
+  if (!exists) {
+    await copy(newKey, copyKey, anvilConfiguration);
+  }
+}
+
+async function copy(newKey, copyKey, anvilConfiguration) {
+  const client = getClient(anvilConfiguration);
+  const source = encodeURI(`/${config.s3.bucket}/${copyKey}`)
+  try {
+    const res = await client.send(new CopyObjectCommand({
+      Bucket: config.s3.bucket,
+      CopySource: source,
+      Key: newKey,
+    }));
+
+    return res;
+  } catch (err) {
+    const message = `Could not copy file in S3 from ${source} to ${newKey}`;
+    console.error(message, err, err?.stack);
+    throw new Error(message);
+  }
+}
+
 export async function checkAndUpload(key, filePath, anvilConfiguration) {
   const exists = await fileExists(key, anvilConfiguration);
 
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index d16a814d..c7eb8080 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -9,8 +9,97 @@ import LibrarySwitcher from "@/components/ui/library/LibrarySwitcher";
 import ModalWrapper from "@/components/ui/modal/ModalWrapper";
 import ToastWrapper from "./components/ui/ToastWrapper";
 import "./styles/globals.scss";
+import AnvilConfigurationsModal from "./components/ui/modal/AnvilConfigurationsModal";
+import ClosableModal from "./components/ui/modal/ClosableModal";
+import { useState, useEffect } from "react";
+import axios from 'axios'
+import { useAtom } from "jotai";
+import { isPackaged} from "@/atoms/kubecontextAtom";
+import { availableKubeContexts } from "@/atoms/kubecontextAtom";
+import {Loading} from "@carbon/react"
 
 export default function App() {
+
+  
+  const [appIsPackaged, setIsPackaged] = useAtom(isPackaged)
+  const [availableKubeContextsAtom, setAvailableKubeContexts] = useAtom(availableKubeContexts)
+  const [configOpen, setConfigOpen] = useState(false)
+  const [confirmationOpen, setConfirmationIsOpen] = useState(false)
+  const [confirmationText, setConfirmationText] = useState([])
+  const [errModalOpen, setErrModalOpen] = useState(false)
+  const [errText, setErrText] = useState(false)
+  const [loading, setIsLoading] = useState(false)
+  
+  useEffect(() => {
+    const serverAddress = import.meta.env.VITE_EXPRESS
+    const res = axios.get(`${serverAddress}/isPackaged`).then((response) => {
+      console.log("CHECK HERE FOR RESPONSE - APP IS PACKAGED???")
+      console.log(response)
+      console.log(response.data)
+      setIsPackaged(response.data)
+      
+
+
+      if(availableKubeContextsAtom.length === 0) {
+        axios.get(`${serverAddress}/get-kube-contexts`).then((res) => {
+            setAvailableKubeContexts(res.data)
+        }
+        )
+    }
+
+      axios.get(`${serverAddress}/get-anvil-config`).then(res => {
+      console.log("CHECK RES")
+      console.log(res)
+      console.log(res.data)
+      
+
+      const data = res.data
+      if(data.has_config) {
+        console.log("I SHOULD BE HERE ON THE RUN")
+        const config = data.config
+        const bucketPort = config.Local.BucketPort
+        const driver = config.Local.Driver
+        const serverPort = config.ServerPort
+        const context = config.KubeContext
+        if(config.IsLocal === true){
+        setConfirmationIsOpen(true)
+        const configText = ["Are you sure you want to run anvil with the following configurations?", "If you are using minikube driver, please make sure you've setted up your minikube cluster, and that it's running.", `HOST: 127.0.0.1`, `PORT: ${serverPort}` , `Context: ${context}`, `Driver: ${driver}`]
+        setConfirmationText(configText)
+        }
+      } else {
+        console.log("NOT HERE")
+        setConfigOpen(true)
+        setConfirmationIsOpen(false)
+      }
+    }).catch(err => {
+      console.log("DEFINITELY NOT HERE")
+      setErrText(["Your local anvil did not started as expected. Please select a config", err.response?.data?.err, err.response?.data?.kubeErr])
+      setConfigOpen(true)
+    })
+
+  })
+
+    
+    
+
+  
+
+  }, [])
+ 
+  const confirmSettings = async () => {
+    setIsLoading(true)
+    const serverAddress = import.meta.env.VITE_EXPRESS
+    try{
+      
+      const res = await axios.post(`${serverAddress}/launch-anvil-from-config`)
+      console.log(res)
+      console.log("CONFIRMATION")
+      setConfirmationIsOpen(false)
+      setIsLoading(false)
+    } catch(err) {
+      setErrText([err.message])
+    }
+  }
   return (
     <ProviderInjector>
       <ForgeTheme>
@@ -19,6 +108,34 @@ export default function App() {
           <BlockEditorPanel />
         </Navbar>
         <LibrarySwitcher />
+        <AnvilConfigurationsModal open={configOpen} onRequestClose={() => setConfigOpen(false)}/>
+        
+
+        {/* Confirmation */}
+        <ClosableModal modalHeading="Would you like to run your anvil locally with your existing settings" size="md" primaryButtonText="Yes" secondaryButtonText="No" onRequestSubmit={confirmSettings} onRequestClose={() => setConfirmationIsOpen(false)} open={confirmationOpen}>
+    <div className="flex flex-col gap-4 p-3">
+          {confirmationText.map((error, i) => {
+            console.log(confirmationText)
+            return (
+              <p key={"error-msg-" + i}>{error}</p>
+            )
+          })}
+        </div>
+        <Loading active={loading} />
+      </ClosableModal>
+      
+      {/* Error */}
+      <ClosableModal modalHeading="Following errors happened, please change your local config, or choose a cloud configuration" size="md" primaryButtonText="Yes" secondaryButtonText="No" passiveModal onRequestClose={() => {setConfirmationIsOpen(false); setConfigOpen(true) }} open={errModalOpen}>
+    <div className="flex flex-col gap-4 p-3">
+          {confirmationText.map((error, i) => {
+            console.log(confirmationText)
+            return (
+              <p key={"error-msg-" + i}>{error}</p>
+            )
+          })}
+        </div>
+      </ClosableModal>
+
         <MainContent>
           <DrawflowWrapper />
         </MainContent>
diff --git a/frontend/src/atoms/kubecontextAtom.js b/frontend/src/atoms/kubecontextAtom.js
new file mode 100644
index 00000000..ebe79165
--- /dev/null
+++ b/frontend/src/atoms/kubecontextAtom.js
@@ -0,0 +1,10 @@
+import {atom} from 'jotai'
+
+export const availableKubeContexts = atom([])
+export const choosenKubeContexts = atom('')
+export const isPackaged = atom(false)
+export const runningKubeContext = atom('')
+export const kubeErrorModalIsOpen = atom(false)
+export const kubeErrors = atom([])
+export const drivers = atom(['docker', 'minikube'])
+export const choosenDriver = atom('')
diff --git a/frontend/src/components/ui/RunPipelineButton.jsx b/frontend/src/components/ui/RunPipelineButton.jsx
index 1f36cff8..fbd701b4 100644
--- a/frontend/src/components/ui/RunPipelineButton.jsx
+++ b/frontend/src/components/ui/RunPipelineButton.jsx
@@ -156,6 +156,7 @@ export default function RunPipelineButton({ children, action }) {
     margin: "5px",
   };
 
+
   return (
     <>
       <Button style={styles} size="sm" onClick={() => runPipeline()}>
diff --git a/frontend/src/components/ui/modal/AnvilConfigurationsModal.jsx b/frontend/src/components/ui/modal/AnvilConfigurationsModal.jsx
index cf2ae07b..70c632e4 100644
--- a/frontend/src/components/ui/modal/AnvilConfigurationsModal.jsx
+++ b/frontend/src/components/ui/modal/AnvilConfigurationsModal.jsx
@@ -7,10 +7,36 @@ import {
   editConfigurationAtom,
 } from "@/atoms/anvilConfigurationsAtom";
 import { useAtom } from "jotai";
+import {
+  Button,
+  NumberInput,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+  TableSelectRow,
+  TextInput,
+  Tab,
+  Tabs,
+  TabList,
+  TabPanel,
+  TabPanels,
+  Tooltip, 
+  Modal,
+  Loading
+} from "@carbon/react";
+import KubecontextModal from "./KubecontextModal";
+import { isPackaged, choosenKubeContexts, choosenDriver } from "@/atoms/kubecontextAtom";
+import { activeConfigurationAtom } from "@/atoms/anvilConfigurationsAtom";
+import axios from 'axios'
 
 const CONFIGURATION_TABLE_TITLE = "Anvil Configurations";
 const NEW_CONFIGURATION_TITLE = "New Configuration";
 const EDIT_CONFGURATION_TITLE = "Edit Configuration";
+
+
 export default function AnvilConfigurationsModal() {
   const [, addConfiguration] = useAtom(addConfigurationAtom);
   const [, editConfiguration] = useAtom(editConfigurationAtom);
@@ -18,6 +44,19 @@ export default function AnvilConfigurationsModal() {
   const [initialConfiguration, setInitialConfiguration] = useState(undefined);
   const [handleSave, setHandleSave] = useState(undefined);
   const [title, setTitle] = useState(CONFIGURATION_TABLE_TITLE);
+  const [defaultAnvilConfiguration] = useAtom(defaultAnvilConfigurationAtom);
+  const [userAnvilConfigurations] = useAtom(userAnvilConfigurationsAtom);
+  const [appIsPackaged] = useAtom(isPackaged)
+  const [confirmationOpen, setConfirmationIsOpen] = useState(false)
+  const [showConfig, setShowConfig] = useState(false)
+  const [configuration] = useAtom(activeConfigurationAtom);
+  const [confirmationText, setConfirmationText] = useState([])
+  const [currentKubeContext, setCurrentKubeContext] = useAtom(choosenKubeContexts)
+  const [selectedDriver] = useAtom(choosenDriver)
+  const [errModalOpen, setErrModalIsOpen] = useState(false)
+  const [errMessage, setErrMessage] = useState([])
+  const [loading, setIsLoading] = useState(false)
+
 
   function handleNew() {
     setInitialConfiguration(undefined);
@@ -30,6 +69,7 @@ export default function AnvilConfigurationsModal() {
     setFormOpen(true);
   }
 
+
   function handleEdit(userConfigurationIndex, configuration) {
     setInitialConfiguration(configuration);
     setHandleSave(() => (newConfiguration) => {
@@ -46,9 +86,65 @@ export default function AnvilConfigurationsModal() {
     setFormOpen(false);
   }
 
+  //~ (configuration.host === 127.0.0.1 || configuration.host === localhost) = con
+  const confirmSettings = async () => {
+    setIsLoading(true)
+    if(configuration.host !== '127.0.0.1' && configuration.host !== 'localhost'){
+      try{
+        const res = await fetch(`https://${configuration.host}:${configuration.anvilPort}/ping`)
+        setIsLoading(false)
+        setConfirmationIsOpen(false)
+
+      } catch(err) {
+        console.log("CANT PING ANVIL")
+        setIsLoading(false)
+        setErrMessage(["Can't Ping Cloud Anvil. Please check you settings"])
+      }
+    } else {
+      const body = {
+        host: configuration.host,
+        anvilPort: configuration.anvilPort,
+        KubeContext: currentKubeContext,
+        s3Port: configuration.s3Port,
+        driver: selectedDriver
+      }
+      try{
+        const serverAddress = import.meta.env.VITE_EXPRESS
+
+        const res = await axios.post(`${serverAddress}/launch-anvil`, body)
+        console.log(res)
+        console.log("CHECK RES HERE")
+        setIsLoading(false)
+        setConfirmationIsOpen(false)
+
+      } catch(err) {
+        console.log("CHECK ERROOORRR")
+        console.log(err)
+        console.log(err.message)
+        setErrMessage([err.response?.data?.err, err.response?.data?.kubeErr])
+        setErrModalIsOpen(true)
+        setIsLoading(false)
+        setConfirmationIsOpen(false)
+      }
+    }
+  }
+
   return (
-    <ClosableModal modalHeading={title} size="md" passiveModal>
-      {formOpen ? (
+    <>
+    <ClosableModal modalHeading="Anvil Configurations" size="md"  initialLaunch={false}  primaryButtonText="Save & Relaunch" primaryButtonDisabled={disable} onRequestSubmit={saveAndRelaunch} modalType="Anvil Config">
+      <Tabs>
+        <TabList>
+          <Tab>
+            Anvil Configurations
+          </Tab>
+          <Tab>
+          {/* <Tab disabled={!appIsPackaged || (configuration.host !== 'localhost' && configuration.host !== '127.0.0.1')} > */}
+          Set KubeContext
+          </Tab> 
+        </TabList>
+        <TabPanels>
+          <TabPanel>
+          {formOpen ? (
         <AnvilConfigurationForm
           onCancel={handleCancel}
           onSave={handleSave}
@@ -57,6 +153,35 @@ export default function AnvilConfigurationsModal() {
       ) : (
         <AnvilConfigurationTable onNew={handleNew} onEdit={handleEdit} />
       )}
+          </TabPanel>
+          <TabPanel>
+            <KubecontextModal isPackaged={appIsPackaged} initialLaunch={false}/>
+          </TabPanel>
+        </TabPanels>      
+      </Tabs>
     </ClosableModal>
+    
+    <ClosableModal modalHeading="Are you sure you want to use this setting" size="md" primaryButtonText="Yes" secondaryButtonText="No" onRequestSubmit={confirmSettings} onRequestClose={() => setConfirmationIsOpen(false)} open={confirmationOpen}>
+    <div className="flex flex-col gap-4 p-3">
+          {confirmationText.map((error, i) => {
+            console.log(confirmationText)
+            return (
+              <p key={"error-msg-" + i}>{error}</p>
+            )
+          })}
+        </div>
+        <Loading active={loading} />
+      </ClosableModal>
+      <ClosableModal modalHeading="Following errors occurred while launching anvil" size="md" passiveModal onRequestClose={() => setErrModalIsOpen(false)} open={errModalOpen}>
+      <div className="flex flex-col gap-4 p-3">
+          {errMessage.map((error, i) => {
+            console.log(confirmationText)
+            return (
+              <p key={"error-msg-" + i}>{error}</p>
+            )
+          })}
+        </div>
+      </ClosableModal>
+    </>
   );
 }
diff --git a/frontend/src/components/ui/modal/ClosableModal.jsx b/frontend/src/components/ui/modal/ClosableModal.jsx
index 588dca3d..c8e530c4 100644
--- a/frontend/src/components/ui/modal/ClosableModal.jsx
+++ b/frontend/src/components/ui/modal/ClosableModal.jsx
@@ -8,6 +8,7 @@ export default function ClosableModal(props) {
   const { children, modalClass, ...modalProps } = props;
 
   const closeModal = () => {
+    
     setModalContent({
       ...modalContent.content,
       show: false,
@@ -29,6 +30,7 @@ export default function ClosableModal(props) {
       {...modalProps}
     >
       {children}
+      
     </Modal>
   );
 }
diff --git a/frontend/src/components/ui/modal/ConfirmationModal.jsx b/frontend/src/components/ui/modal/ConfirmationModal.jsx
new file mode 100644
index 00000000..144f3e5b
--- /dev/null
+++ b/frontend/src/components/ui/modal/ConfirmationModal.jsx
@@ -0,0 +1,11 @@
+import ClosableModal from "./ClosableModal";
+import { useState } from "react";
+
+
+export default function ConfirmationModal() {
+    
+
+    <ClosableModal modalHeading="Anvil Configurations" size="md"  initialLaunch={false} primaryButtonText="Save & Relaunch" onRequestSubmit={() => {}}>
+        
+    </ClosableModal>
+}
\ No newline at end of file
diff --git a/frontend/src/components/ui/modal/InitialLaunchModal.jsx b/frontend/src/components/ui/modal/InitialLaunchModal.jsx
new file mode 100644
index 00000000..93b9bc9e
--- /dev/null
+++ b/frontend/src/components/ui/modal/InitialLaunchModal.jsx
@@ -0,0 +1,113 @@
+import { isPackaged } from "@/atoms/kubecontextAtom";
+import { Modal, Loading } from "@carbon/react";
+import KubecontextModal from "./KubecontextModal";
+import { useState, useEffect } from "react";
+import { useAtom } from 'jotai'
+import ClosableModal from "./ClosableModal";
+import { choosenKubeContexts, availableKubeContexts, runningKubeContext, kubeErrors} from '@/atoms/kubecontextAtom'
+import { defaultAnvilConfigurationAtom } from "@/atoms/anvilConfigurationsAtom";
+import axios from 'axios'
+
+
+export default function InitialLaunchModal() {
+    const [appIsPackaged, setIsPackaged] = useAtom(isPackaged)
+    const [open, setOpen] = useState(false)
+    const [errOpen, setErrOpen] = useState(false)
+    const [availableKubeContextsAtom, setAvailableKubeContexts] = useAtom(availableKubeContexts)
+    const [currentRunningKubeContext]= useAtom(runningKubeContext)
+    const serverAddress = import.meta.env.VITE_EXPRESS
+    const [errMessage, setErrMessage] = useState([])
+    const [defaultConfig] = useAtom(defaultAnvilConfigurationAtom)
+    const [loading, setIsLoading] = useState(true)
+    const closeModal = () => {
+        axios.get(`http://${defaultConfig.host}:${defaultConfig.anvilPort}/ping`).then((res) => {
+            setOpen(false)
+        }).catch(err => {
+            const errMessage = ["Can't ping anvil. Please re-try"]
+            setErrMessage(errMessage)
+            setOpen(true)
+            setErrOpen(true)
+        })
+    }
+
+    useEffect(() => {
+        
+        if(availableKubeContextsAtom.length === 0) {
+            axios.get(`${serverAddress}/get-kube-contexts`).then((res) => {
+                setAvailableKubeContexts(res.data)
+            }
+            ).catch(err => {
+                console.log('This should not throw err.')
+            })
+        }
+        const checkPing = async () => {
+            try {
+                const res = await axios.get(`http://${defaultConfig.host}:${defaultConfig.anvilPort}/ping`)
+                if(res.status === 200) {
+                    console.log("ALREADY PINGING ANVIL")
+                    setIsLoading(false)
+                    return true
+                } else {
+                    console.log("PING FAILEDDD1111")
+                    return false
+                }
+
+            } catch(err) {
+                console.log("PING FAILEDDD222")
+                return false
+            }
+        }
+        
+        checkPing().then((res) => {
+            if(res == true) {
+                setOpen(false)
+            } else{
+                axios.post(`${serverAddress}/initial-anvil-launch`).then((anvilResponse) => {
+                    if(anvilResponse.status === 200){
+                        setOpen(false)
+                        setIsLoading(false)
+                    } else {
+                        console.log("CHECK IF KUBEERROR HAPPENS HERE??")
+                        setOpen(true)
+                        setIsLoading(false)
+                    }
+                }).catch((err) => {
+                    console.log("CHECK IF KUBEERROR HAPPENS HERE222")
+                    console.log(err)
+                    setOpen(true)
+                    setIsLoading(false)
+                })
+            }
+            
+        })
+
+    }, [])
+
+    if(appIsPackaged === false) {
+        console.log("U SHOULDNt be hereeeeee")
+        return <></>
+    }
+
+    return (
+    <>
+    <Loading active={loading} />
+    <Modal modalHeading="Please select a kubecontext" passiveModal open={open} onRequestClose={closeModal}>
+        <KubecontextModal isPackaged={true} initialLaunch={true} closeFunc={() => setOpen(false)}/>
+    </Modal>
+
+<ClosableModal
+modalHeading="The following error(s) occurred:"
+passiveModal={true}
+open={errOpen}
+onRequestClose={() => setErrOpen(false)}
+>
+<div className="flex flex-col gap-4 p-3">
+  {errMessage.map((error, i) => {
+    return (
+      <p key={"error-msg-" + i}>{error}</p>
+    )
+  })}
+</div>
+</ClosableModal>
+</>)
+}
\ No newline at end of file
diff --git a/frontend/src/components/ui/modal/KubecontextModal.jsx b/frontend/src/components/ui/modal/KubecontextModal.jsx
new file mode 100644
index 00000000..a66e99df
--- /dev/null
+++ b/frontend/src/components/ui/modal/KubecontextModal.jsx
@@ -0,0 +1,146 @@
+import {Dropdown, Button, Loading, Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,} from '@carbon/react'
+import {useAtom} from 'jotai'
+import { useImmerAtom } from "jotai-immer";
+import ClosableModal from './ClosableModal';
+import { choosenKubeContexts, availableKubeContexts, runningKubeContext, kubeErrors, drivers, choosenDriver} from '@/atoms/kubecontextAtom'
+import { defaultAnvilConfigurationAtom } from '@/atoms/anvilConfigurationsAtom';
+import { useState, useEffect } from 'react'
+import axios from 'axios'
+import {trpc} from '@/utils/trpc'
+import { useImmer } from 'use-immer';
+export default function KubecontextModal({isPackaged, initialLaunch, closeFunc}) {
+  const [showModal, setShowModal] = useState(false)
+  const [availableKubeContextsAtom, setAvailableKubeContexts] = useAtom(availableKubeContexts)
+  const [allKubecontexts, setAllKubeContexts] = useState([])
+  const [defaultAnvilConfiguration] = useAtom(defaultAnvilConfigurationAtom)
+  const [currentKubeContext, setCurrentKubeContext] = useImmerAtom(choosenKubeContexts)
+  const [currentRunningKubeContext, setCurrentRunningKubeContext] = useAtom(runningKubeContext)
+  const [errValidMessages, setErrMessage] = useAtom(kubeErrors)
+  const [isOpen, setIsOpen] = useState(false)
+  const [loading, setIsLoading] = useState(false)
+  const [availableDrivers] = useAtom(drivers)
+  const [userDriver, setChoosenDriver] = useAtom(choosenDriver)
+
+  useEffect(() => {
+    const serverAddress = import.meta.env.VITE_EXPRESS
+        if(availableKubeContextsAtom.length === 0) {
+            axios.get(`${serverAddress}/get-kube-contexts`).then((res) => {
+                console.log("CHECK KUBES")
+                console.log(res.data)
+                setAvailableKubeContexts(res.data)
+            }
+            ).catch(err => {
+              console.log(err)
+            })
+        }
+  }, [])
+  
+
+  const submit = async () => {
+    setIsLoading(true)
+    const serverAddress = import.meta.env.VITE_EXPRESS
+
+    console.log("SUBMIT")
+    console.log(currentKubeContext)
+    const reqBody = {
+        host: defaultAnvilConfiguration.host,
+        anvilPort: defaultAnvilConfiguration.anvilPort,
+        KubeContext: currentKubeContext,
+        s3Port: defaultAnvilConfiguration.s3Port,
+    }
+    
+    try {
+        console.log("CHANGE ANVIL CONFIG")
+        console.log(reqBody)
+        const executeAnvil = await axios.post(`${serverAddress}/launch-anvil`, reqBody)
+        if(executeAnvil.status !== 200) {
+            console.log("ERROR CREAATING ANVIL EXEC")
+            setIsLoading(false)
+        } else{
+            console.log("ANVIL LAUNCH SUCCESSFULLLLLLLL")
+            setIsLoading(false)
+            closeFunc()
+            setCurrentKubeContext('')
+            setChoosenDriver('')
+        }
+        console.log("ERROR LAUNCH ANVIL HERE")
+        setIsLoading(false)
+    } catch(err) {
+        console.log("ERROR LAUNCH ANVIL")
+        console.log(err.response.data)
+        const errorData = err.response.data
+        const errorMessages = [errorData?.err, errorData?.kubeErr]
+        console.log(errorMessages)
+        setErrMessage(errorMessages)
+        setIsOpen(true)
+        setIsLoading(false)
+
+    }
+
+  }
+
+  const handleSelection = async (e) => {
+    try{
+    setCurrentKubeContext(draft => {
+        return e.selectedItem
+    })
+    } catch (err) {
+        console.log(err)
+    }
+  }
+
+  const handleDriverSelection = async (e) => {
+    setChoosenDriver(e.selectedItem)
+  }
+
+  
+
+return (   <>
+          <Table>
+
+            <TableHead>
+                <TableRow>
+                  <TableHeader>
+                    KubeContext
+                  </TableHeader>
+                  <TableHeader>
+                    Driver
+                  </TableHeader>
+              </TableRow>
+            </TableHead>
+
+            <TableBody>
+              <TableRow>
+                <TableCell>
+                <Dropdown items={availableKubeContextsAtom} onChange={handleSelection}/>
+                </TableCell>
+                <TableCell>
+                <Dropdown items={availableDrivers} onChange={handleDriverSelection}/>
+                </TableCell>
+              </TableRow>
+            </TableBody>
+          </Table>
+          <div className='err-modal'>
+          <ClosableModal
+        modalHeading="The following error(s) occurred:"
+        passiveModal={true}
+        open={isOpen}
+        onRequestClose={() => setIsOpen(false)}
+      >
+        <div className="flex flex-col gap-4 p-3">
+          {errValidMessages.map((error, i) => {
+            return (
+              <p key={"error-msg-" + i}>{error}</p>
+            )
+          })}
+        </div>
+      </ClosableModal>
+      </div>
+          </>
+        )
+}
\ No newline at end of file
diff --git a/frontend/src/styles/beautiful.css b/frontend/src/styles/beautiful.css
index 76dd0437..df05013f 100644
--- a/frontend/src/styles/beautiful.css
+++ b/frontend/src/styles/beautiful.css
@@ -474,3 +474,10 @@ header a {
 /* #view-btn:hover {
   box-shadow: 0 0 10px 5px rgba(255, 255, 255, 0.6);
 } */
+
+
+.err-modal .cds--modal-container{
+	position: absolute;
+	left: 30px;
+	right:30px
+}
diff --git a/frontend/src/styles/library.scss b/frontend/src/styles/library.scss
index 5ecf15ea..1cbb7fe1 100644
--- a/frontend/src/styles/library.scss
+++ b/frontend/src/styles/library.scss
@@ -106,7 +106,11 @@
 
 .custom-modal-size .cds--modal-content {
 }
+<<<<<<< HEAD
 .cds--tabs .cds--tabs__nav-link:focus,
 .cds--tabs .cds--tabs__nav-link:active {
+=======
+.cds--tabs .cds--tabs__nav-link:focus, .cds--tabs .cds--tabs__nav-link:active {
+>>>>>>> squashing commits before rebase
   outline: none !important;
 }
diff --git a/zetaforge/__init__.py b/zetaforge/__init__.py
index db67ade4..03945793 100644
--- a/zetaforge/__init__.py
+++ b/zetaforge/__init__.py
@@ -1,2 +1,2 @@
 __version__ = '0.2.1'
-from .block_maker.zetahelper import block_maker
\ No newline at end of file
+from .block_maker.zetahelper import block_maker
diff --git a/zetaforge/forge_runner.py b/zetaforge/forge_runner.py
index c92a59ed..3d85b6b3 100644
--- a/zetaforge/forge_runner.py
+++ b/zetaforge/forge_runner.py
@@ -241,7 +241,7 @@ def run_forge(server_version=None, client_version=None, server_path=None, client
         print(f"Launching client {client_path}..")
         client_executable = os.path.basename(client_path)
         if platform.system() == 'Darwin':
-            client_executable = [f"./{client_executable}"]
+            client_executable = [f"./{client_executable}", "--is_pip"]
         elif platform.system() == 'Windows':
             client_executable = [client_path, '--no-sandbox']
         else: