pinokiod 3.40.0 → 3.42.0

package/server/index.js

@@ -23,6 +23,7 @@ const fse = require('fs-extra')
 const QRCode = require('qrcode')
 const axios = require('axios')
 const crypto = require('crypto')
+const serveIndex = require('serve-index')
 
 const git = require('isomorphic-git')
 const http = require('isomorphic-git/http/node')
@@ -60,8 +61,6 @@ function normalize(str) {
 
 class Server {
   constructor(config) {
-    this.menu_hidden = {}
-    this.selected = {}
     this.tabs = {}
     this.agent = config.agent
     this.port = DEFAULT_PORT
@@ -112,38 +111,6 @@ class Server {
   exists (s) {
     return new Promise(r=>fs.access(s, fs.constants.F_OK, e => r(!e)))
   }
-  async updateMeta(formData, app_path) {
-    // write title/description to pinokio.json
-    let dirty
-    let meta_path = this.kernel.path("api", app_path, "pinokio.json")
-    let meta = (await this.kernel.loader.load(meta_path)).resolved
-    if (!meta) meta = {}
-    if (formData.title) {
-      meta.title = formData.title
-      dirty = true
-    }
-    if (formData.description) {
-      meta.description = formData.description
-      dirty = true
-    }
-    if (!meta.plugin) {
-      meta.plugin = {
-        menu: []
-      }
-    }
-
-    if (formData.icon_dirty) {
-      // 
-      // write icon file
-      let icon_path = this.kernel.path("api", formData.new_path, formData.icon_path)
-      await fs.promises.writeFile(icon_path, formData.avatar)
-      meta.icon = formData.icon_path
-      dirty = true
-    }
-    if (dirty) {
-      await fs.promises.writeFile(meta_path, JSON.stringify(meta, null, 2))
-    }
-  }
   running_dynamic (name, menu) {
     let cwd = this.kernel.path("api", name)
     let running_dynamic = []
@@ -204,24 +171,6 @@ class Server {
     traverse(menu)
     return running_dynamic
   }
-  async createMeta(formData) {
-    let _path = this.kernel.path("api", formData.path)
-    await fs.promises.mkdir(_path, { recursive: true }).catch((e) => {})
-    let icon_path = this.kernel.path("api", formData.path, "icon.png")
-    await fs.promises.writeFile(icon_path, formData.avatar)
-
-    // write title/description to pinokio.json
-    let meta_path = this.kernel.path("api", formData.path, "pinokio.json")
-    let meta = {
-      title: formData.title,
-      description: formData.description,
-      icon: "icon.png",
-      plugin: {
-        menu: []
-      }
-    }
-    await fs.promises.writeFile(meta_path, JSON.stringify(meta, null, 2))
-  }
   getMemory(filepath) {
     let localMem = this.kernel.memory.local[filepath]
     let globalMem = this.kernel.memory.global[filepath]
@@ -287,14 +236,22 @@ class Server {
         name = x.name
         description = ""
       }
+
+
       let browser_url 
+      let target
+
       if (x.run) {
         browser_url = "/env/api/" + x.name
       } else {
         //browser_url = "/pinokio/browser/" + x.name
         browser_url = "/p/" + x.name
       }
-      let browser_browse_url = browser_url + "/dev"
+      let dev_url = browser_url + "/dev"
+      let review_url = browser_url + "/review"
+
+      let dns = this.kernel.pinokio_configs[x.name].dns
+      let routes = dns["@"]
       return {
         filepath: this.kernel.path("api", x.name),
         icon,
@@ -313,12 +270,86 @@ class Server {
         description,
         url: p + "/" + x.name,
         browser_url,
+        target,
         url: browser_url,
         path: uri,
-        browse_url: browser_browse_url,
+        dev_url,
+        review_url,
       }
     })
   }
+  async getGit(ref, filepath) {
+    let dir = this.kernel.path("api", filepath)
+    let branches = await git.listBranches({ fs, dir });
+    let log = []
+    try {
+      log = await git.log({ fs, dir, depth: 50, ref: ref }); // fetch last 50 commits
+      log.forEach((item) => {
+        item.info = `/gitcommit/${item.oid}/${filepath}`
+      })
+    } catch (e) {
+      console.log("Log error", e)
+    }
+
+    let config = await this.kernel.git.config(dir)
+
+    let hosts = ""
+    let hosts_file = this.kernel.path("config/gh/hosts.yml")
+    let e = await this.exists(hosts_file)
+    if (e) {
+      hosts = await fs.promises.readFile(hosts_file, "utf8")
+      if (hosts.startsWith("{}")) {
+        hosts = ""
+      }
+    }
+    let connected = (hosts.length > 0)
+    let remote = null
+    if (config["remote \"origin\""]) {
+      remote = config["remote \"origin\""].url
+    }
+
+    let branch = await git.currentBranch({ fs, dir, fullname: false });
+
+    const remote2 = await git.getConfig({
+      fs,
+      dir,
+      path: `branch.${branch}.remote`
+    });
+
+    // if current branch exitss => currengt branch is selected
+    // if current branch does not exist => get logs[0].oid
+    if (branch) {
+      branches = branches.map((b) => {
+        if (b === branch) {
+          return {
+            branch: b,
+            selected: true
+          }
+        } else {
+          return {
+            branch: b,
+            selected: false
+          }
+        }
+      })
+    } else {
+      branches.push(log[0].oid)
+      branches = branches.map((b) => {
+        if (b === log[0].oid) {
+          return {
+            branch: b,
+            selected: true
+          }
+        } else {
+          return {
+            branch: b,
+            selected: false
+          }
+        }
+      })
+    }
+    return { ref, config, remote, connected, log, branch, branches, dir }
+  }
   async init_env(env_dir_path, options) {
     let current = this.kernel.path(env_dir_path, "ENVIRONMENT")
       // if environment.json doesn't exist, 
@@ -338,7 +369,7 @@ class Server {
           await fs.promises.writeFile(current, _environmentStr)
         }
       } else {
-        let content = await Environment.ENV("app", this.kernel.homedir)
+        let content = await Environment.ENV("app", this.kernel.homedir, this.kernel)
         if (_exists) {
           let _environmentStr = await fs.promises.readFile(_environment, "utf8")
           await fs.promises.writeFile(current, _environmentStr + "\n\n\n" + content)
@@ -348,31 +379,45 @@ class Server {
       }
     }
   }
-  async current_urls(current_path) {
-    let router_running = await this.check_router_up()
-    let u = new URL("http://localhost:42000")
-
-    let current_urls = {}
-
-    // http
-    if (current_path) {
-      u.pathname = current_path
-    }
-    current_urls.http = u.toString()
-
-    // https
-    if (router_running.success) {
-      let u = new URL("https://pinokio.localhost")
-      if (current_path) {
-        u.pathname = current_path
+  async get_github_hosts() {
+    let hosts = ""
+    let hosts_file = this.kernel.path("config/gh/hosts.yml")
+    let e = await this.exists(hosts_file)
+    if (e) {
+      hosts = await fs.promises.readFile(hosts_file, "utf8")
+      if (hosts.startsWith("{}")) {
+        hosts = ""
       }
-      current_urls.https = u.toString()
     }
-
-    return current_urls
+    return hosts
+  }
+  async current_urls(current_path) {
+    return {}
+//    let router_running = await this.check_router_up()
+//    let u = new URL("http://localhost:42000")
+//
+//    let current_urls = {}
+//
+//    // http
+//    if (current_path) {
+//      u.pathname = current_path
+//    }
+//    current_urls.http = u.toString()
+//
+//    // https
+//    if (router_running.success) {
+//      let u = new URL("https://pinokio.localhost")
+//      if (current_path) {
+//        u.pathname = current_path
+//      }
+//      current_urls.https = u.toString()
+//    }
+//
+//    return current_urls
   }
 
   async chrome(req, res, type) {
+
     let d = Date.now()
     let { requirements, install_required, requirements_pending, error } = await this.kernel.bin.check({
       bin: this.kernel.bin.preset("dev"),
@@ -408,32 +453,6 @@ class Server {
       }
     }
 
-
-
-//    let requires_instantiation = false
-//    console.log("## CONFIG", config)
-//    if (config && config.pre) {
-//      let env = await Environment.get2(app_path, this.kernel)
-//      for(let item of config.pre) {
-//        console.log("ITEM" , item)
-//        if (item.env) {
-//          if (env[item.env]) {
-//            
-//          } else {
-//            requires_instantiation = true
-//            break;
-//          }
-//        }
-//      }
-//    }
-//    console.log({ requires_instantiation })
-//    if (requires_instantiation) {
-//      // redirect to pre
-//      res.redirect("/required_env/api/" + name)
-//      return
-//    }
-
-
     let menu = config.menu || []
     try {
       if (typeof config.menu === "function") {
@@ -448,80 +467,53 @@ class Server {
       config.menu = []
     }
 
+
     let uri = this.kernel.path("api")
     try {
+      let launcher = await this.kernel.api.launcher(name)
+      req.launcher_root = launcher.launcher_root
       await this.renderMenu(req, uri, name, config, [])
     } catch(e) {
       config.menu = []
       err = e.stack
     }
 
-
     let platform = os.platform()
 
-//    if (config.icon) {
-//      //config.iconpath = this.kernel.path("api", name, config.icon)
-//      config.iconpath = config.icon
-//      config.icon = `${rawpath}/${config.icon}?raw=true`
-//    } else {
-//      //config.iconpath = this.kernel.path("api", name, "pinokio_icon.png")
-//      config.iconpath = "pinokio.png"
-//      config.icon = "/pinokio-black.png"
-//    }
-
-
-//    // get all memory variable stied to the current repository
-//    let api_path = this.kernel.path("api", name)
-//    let mem = {}
-//    for(let type in this.kernel.memory) {
-//      // type := local|global
-//      let vars = this.kernel.memory[type]
-//      for(let k in vars) {
-//        if (k.includes(api_path)) {
-//          if (mem[k]) {
-//            mem[k][type] = vars[k]
-//          } else {
-//            mem[k] = {
-//              [type]: vars[k]
-//            }
-//          }
-//        }
-//      }
-//    }
-
-//    console.time("2 chrome " + d)
-    await this.init_env("api/" + name)
+    await Environment.init({ name }, this.kernel)
 
     // copy gitignore from ~pinokio/prototype/system/gitignore if it doesn't exist
 
 
     let gitignore_path = this.kernel.path("api/" + name + "/.gitignore")
+    let dot_path = this.kernel.path("api", name, "pinokio")
     let gitignore_template_path = this.kernel.path("prototype/system/gitignore")
     let template_exists = await this.exists(gitignore_template_path)
     if (template_exists) {
-      await Util.mergeLines(
-        gitignore_path, // existing path
-        gitignore_template_path // overwrite with template
-      )
+      let exists = await this.exists(dot_path)
+      if (exists) {
+        // 1. when importing existing projects (.pinokio exists), don't mess with .gitignore
+      } else {
+        // 2. otherwise, merge gitignore
+        await Util.mergeLines(
+          gitignore_path, // existing path
+          gitignore_template_path // overwrite with template
+        )
+      }
     }
 
 
 
 
-//    console.timeEnd("2 chrome " + d)
-
-//    console.time("3 chrome " + d)
     let mode = "run"
     if (req.query && req.query.mode) {
       mode = req.query.mode
     }
     const env = await this.kernel.env("api/" + name)
-//    console.timeEnd("3 chrome " + d)
 
     // profile + feed
     const repositoryPath = path.resolve(this.kernel.api.userdir, name)
 
-//    console.time("4 chrome " + d)
     try {
       await git.resolveRef({ fs, dir: repositoryPath, ref: 'HEAD' });
     } catch (err) {
@@ -530,9 +522,6 @@ class Server {
       await git.init({ fs, dir: repositoryPath });
     }
 
-//    console.timeEnd("4 chrome " + d)
-
-//    console.time("5 chrome " + d)
     let gitRemote = await git.getConfig({ fs, http, dir: repositoryPath, path: 'remote.origin.url' })
     let profile
     let feed
@@ -541,24 +530,18 @@ class Server {
 
       let system_env = {}
       if (this.kernel.homedir) {
-        system_env = await Environment.get(this.kernel.homedir)
+        system_env = await Environment.get(this.kernel.homedir, this.kernel)
       }
       profile = this.profile(gitRemote)
       feed = this.newsfeed(gitRemote)
     }
-//    console.timeEnd("5 chrome " + d)
 
     // git
 
     let c = this.kernel.path("api", name)
 
-//    console.time("6 chrome " + d)
 //    await this.kernel.plugin.init()
-//    console.timeEnd("6 chrome " + d)
-//    console.time("7 chrome " + d)
 //    let plugin = await this.getPlugin(name)
-//    console.timeEnd("7 chrome " + d)
-//    console.time("8 chrome " + d)
 //    let plugin_menu = null
 //    if (plugin && plugin.menu && Array.isArray(plugin.menu)) {
 //      let running_dynamic = this.running_dynamic(name, plugin.menu)
@@ -569,15 +552,12 @@ class Server {
     let current_urls = await this.current_urls(req.originalUrl.slice(1))
 
     let plugin_menu = null
-    let plugin = await this.getPlugin(req, name)
+    let plugin_config = structuredClone(this.kernel.plugin.config)
+    let plugin = await this.getPlugin(req, plugin_config, name)
     if (plugin && plugin.menu && Array.isArray(plugin.menu)) {
       plugin = structuredClone(plugin)
       plugin_menu = this.running_dynamic(name, plugin.menu)
     }
-    let menu_hidden = false
-    if (this.menu_hidden[name] && this.menu_hidden[name][type]) {
-      menu_hidden = true
-    }
 
     let posix_path = Util.p2u(this.kernel.path("api", name))
     let dev_link
@@ -587,9 +567,13 @@ class Server {
       dev_link = "/d/" + posix_path
     }
 
+    let run_tab = "/p/" + name
+    let dev_tab = "/p/" + name + "/dev"
+    let review_tab = "/p/" + name + "/review"
+
+
     const result = {
       dev_link,
-      minimized: menu_hidden,
 //      repos,
       current_urls,
       path: this.kernel.path("api", name),
@@ -619,20 +603,22 @@ class Server {
       config,
 //        sidebar_url: "/pinokio/sidebar/" + name,
       home: req.originalUrl,
+      run_tab,
+      dev_tab,
+      review_tab,
 //        paths,
       theme: this.theme,
       agent: this.agent,
       src: "/_api/" + name,
       logs: "/_api/" + name + "/logs",
       execUrl: "/api/" + name,
+      git_monitor_url: `/gitcommit/HEAD/${name}`,
+      git_history_url: `/info/git/HEAD/${name}`,
 //      rawpath,
     }
-//    console.timeEnd("8 chrome " + d)
-//    console.time("9 chrome " + d)
 //    if (!this.kernel.proto.config) {
 //      await this.kernel.proto.init()
 //    }
-//    console.timeEnd("9 chrome " + d)
     res.render("app", result)
   }
   getVariationUrls(req) {
@@ -651,12 +637,13 @@ class Server {
     return { editorUrl, prevUrl }
   }
   get_shell_id(name, i, rendered) {
-    let hash = crypto.createHash('md5').update(JSON.stringify(rendered)).digest('hex')
     let shell_id
     if (rendered.id) {
       shell_id = encodeURIComponent(`${name}_${rendered.id}`)
     } else {
-      shell_id = encodeURIComponent(`${name}_${i}_session_${hash}`)
+      let hash = crypto.createHash('md5').update(JSON.stringify(rendered)).digest('hex')
+      //shell_id = encodeURIComponent(`${name}_${i}_session_${hash}`)
+      shell_id = encodeURIComponent(`${name}_session_${hash}`)
     }
     return shell_id
   }
@@ -728,50 +715,11 @@ class Server {
 
     }
 
-//    if (pathComponents.length > 1) {
-//      if (pathComponents[1] === 'web') {
-//        let filepath = this.kernel.path("api", ...pathComponents)
-//        console.log("filepath", filepath)
-//        try {
-//          console.log("testing")
-//          let stat = await fs.promises.stat(filepath)
-//          console.log("stat", stat)
-//          // if it's a folder
-//          if (stat.isDirectory()) {
-//            //  if the current folder has "index.html", send that file
-//            //  otherwise 404
-//            let indexFile = path.resolve(filepath, "index.html")
-//            let exists = await this.exists(indexFile)
-//            if (exists) {
-//              res.sendFile(indexFile)
-//            } else {
-//            //  res.redirect("/api/" + pathComponents[0])
-//              res.status(404).render("404", {
-//                message: "index.html not found"
-//              })
-//            }
-//          } else if (stat.isFile()) {
-//            res.sendFile(filepath)
-//          }
-//          return
-//        } catch (e) {
-//          console.log("E", e)
-//          res.redirect("/api/" + pathComponents[0])
-//          return
-//          /*
-//          res.status(404).render("404", {
-//            message: e.message
-//          })
-//          */
-//        }
-//      }
-//    }
-
     if (path.basename(filepath) === "ENVIRONMENT") {
       // if environment.json doesn't exist, 
       let exists = await this.exists(filepath)
       if (!exists) {
-        let content = await Environment.ENV("app", this.kernel.homedir)
+        let content = await Environment.ENV("app", this.kernel.homedir, this.kernel)
         await fs.promises.writeFile(filepath, content)
       }
     }
@@ -816,7 +764,7 @@ class Server {
     } else if (pathComponents.length === 0 && req.query.mode === "settings") {
       let system_env = {}
       if (this.kernel.homedir) {
-        system_env = await Environment.get(this.kernel.homedir)
+        system_env = await Environment.get(this.kernel.homedir, this.kernel)
       }
       let configArray = [{
         key: "home",
@@ -837,7 +785,7 @@ class Server {
       }, {
         key: "mode",
         val: this.mode,
-        options: ["full", "minimal"]
+        options: ["desktop", "background"]
       }, {
         key: "HTTP_PROXY",
         val: (system_env.HTTP_PROXY || ""),
@@ -862,7 +810,10 @@ class Server {
           drive: path.resolve(this.kernel.homedir, "drive"),
         }
       }
+      let list = this.getPeers()
       res.render("settings", {
+        list,
+        current_host: this.kernel.peer.host,
         platform,
         version: this.version,
         logo: this.logo,
@@ -1068,23 +1019,23 @@ class Server {
         let env_requirements = await Environment.requirements(resolved, cwd, this.kernel)
         if (env_requirements.requires_instantiation) {
           //let p = Util.api_path(filepath, this.kernel)
-          let p = Util.api_path(cwd, this.kernel)
+          let api_path = Util.api_path(cwd, this.kernel)
+          let root = await Environment.get_root({ path: api_path }, this.kernel)
+          let root_path = root.root
           let platform = os.platform()
           if (platform === "win32") {
-            p = p.replace(/\\/g, '\\\\')
+            root_path = root_path.replace(/\\/g, '\\\\')
           }
-          console.log({ p, cwd })
+          console.log({ cwd, api_path, root, root_path })
           res.render("required_env_editor", {
             portal: this.portal,
             agent: this.agent,
             theme: this.theme,
             filename,
-            filepath: p,
+            filepath: root_path,
             items: env_requirements.items
           })
         } else {
-          console.log("req.query.callback", req.query.callback)
-
           // check if it's a prototype script
           let kill_message
           let callback
@@ -1162,7 +1113,6 @@ class Server {
         })
       }
     } else if (stat.isDirectory()) {
-
       if (req.query && req.query.mode === "browser") {
         return
       }
@@ -1185,12 +1135,11 @@ class Server {
         }
 
         for(let file of files) {
-          if (!file.name.startsWith(".")) {
-            if (file.isDirectory()) {
-              f.folders.push(file)
-            } else {
-              f.files.push(file)
-            }
+          let type = await Util.file_type(filepath, file)
+          if (type.directory) {
+            f.folders.push(file)
+          } else {
+            f.files.push(file)
           }
         }
 
@@ -1210,8 +1159,6 @@ class Server {
             let p = path.resolve(filepath, file.name)
             config  = (await this.kernel.loader.load(p)).resolved
 
-
-
             if (config && config.menu) {
               if (typeof config.menu === "function") {
                 if (config.menu.constructor.name === "AsyncFunction") {
@@ -1272,8 +1219,13 @@ class Server {
 
 
   //      let folder = pathComponents[pathComponents.length - 1]
-
-        items = f.folders.concat(f.files)
+        if (meta) {
+          // home => only show the folders
+          items = f.folders
+        } else {
+          // app view file explorer => show all files and folders
+          items = f.folders.concat(f.files)
+        }
 //      }
       let display = pathComponents.length === 0 ? ["form", "explore"] : []
       //let display = ["form"]
@@ -1329,9 +1281,16 @@ class Server {
         let index = 0
         for(let i=0; i<items.length; i++) {
           let item = items[i]
-          let p = path.resolve(uri, item.name, "pinokio.js")
-          let config  = (await this.kernel.loader.load(p)).resolved
+          let launcher = await this.kernel.api.launcher(item.name)
+          let config = launcher.script
+          await this.kernel.dns({
+            name: item.name,
+            config
+          })
+
+
           if (config) {
+
             if (config.shortcuts) {
               if (typeof config.shortcuts === "function") {
                 if (config.shortcuts.constructor.name === "AsyncFunction") {
@@ -1414,8 +1373,9 @@ class Server {
                   // other global scripts
                   let chunks = key.split("?")
                   let dev = chunks[0]
-                  let name_chunks = dev.split(path.sep)
-                  let name = name_chunks[name_chunks.length-1]
+                  let relpath = path.relative(this.kernel.homedir, dev)
+                  let name_chunks = relpath.split(path.sep)
+                  let name = "/" + relpath
                   items[i].running_scripts.push({ id: key, name })
                 }
               } else {
@@ -1603,6 +1563,7 @@ class Server {
           items
         })
       } else {
+        console.log("RENDER FILE EXPLORER")
         res.render("file_explorer", {
           docs: this.docs, 
           portal: this.portal,
@@ -1819,9 +1780,10 @@ class Server {
 ////        icon: "fa-solid fa-gear"
 //      }].concat(config.menu)
 
+      let launcher_root = req.launcher_root || ""
+
       for(let i=0; i<config.menu.length; i++) {
         let menuitem = config.menu[i]
-
         if (menuitem.menu) {
           let newIndexPath
           if (indexPath) {
@@ -1841,10 +1803,10 @@ class Server {
             // href resolution
             if (menuitem.fs) {
               // file explorer
-              config.menu[i].href = path.resolve(this.kernel.homedir, "api", name, menuitem.href)
+              config.menu[i].href = path.resolve(this.kernel.homedir, "api", name, launcher_root, menuitem.href)
             } else if (menuitem.command) {
               // file explorer
-              config.menu[i].href = path.resolve(this.kernel.homedir, "api", name, menuitem.href)
+              config.menu[i].href = path.resolve(this.kernel.homedir, "api", name, launcher_root, menuitem.href)
             } else {
               if (menuitem.href.startsWith("/")) {
                 config.menu[i].href = menuitem.href
@@ -1853,7 +1815,11 @@ class Server {
                 let seed = path.resolve(__dirname)
                 let p = absolute.replace(seed, "")
                 let link = p.split(/[\/\\]/).filter((x) => { return x }).join("/")
-                config.menu[i].href = "/api/" + name + "/" + link
+                if (launcher_root) {
+                  config.menu[i].href = "/api/" + name + "/" + launcher_root + "/" + link
+                } else {
+                  config.menu[i].href = "/api/" + name + "/" + link
+                }
               }
             }
           } else if (menuitem.run) {
@@ -1862,12 +1828,21 @@ class Server {
             if (typeof rendered.run === "object") {
               let run = rendered.run
               config.menu[i].run = run.message
-              config.menu[i].cwd = run.path ? path.resolve(this.kernel.homedir, "api", name, run.path) : path.resolve(this.kernel.homedir, "api", name)
-              config.menu[i].href = "/api/" + name
+              if (launcher_root) {
+                config.menu[i].cwd = run.path ? path.resolve(this.kernel.homedir, "api", name, launcher_root, run.path) : path.resolve(this.kernel.homedir, "api", name, launcher_root)
+                config.menu[i].href = "/api/" + name + "/" + launcher_root
+              } else {
+                config.menu[i].cwd = run.path ? path.resolve(this.kernel.homedir, "api", name, run.path) : path.resolve(this.kernel.homedir, "api", name)
+                config.menu[i].href = "/api/" + name
+              }
             } else {
               config.menu[i].run = rendered.run
-              config.menu[i].cwd = path.resolve(this.kernel.homedir, "api", name)
-              config.menu[i].href = "/api/" + name
+              config.menu[i].cwd = path.resolve(this.kernel.homedir, "api", launcher_root, name)
+              if (launcher_root) {
+                config.menu[i].href = "/api/" + name + "/" + launcher_root
+              } else {
+                config.menu[i].href = "/api/" + name
+              }
             }
           }
         }
@@ -1878,8 +1853,13 @@ class Server {
 
 
         if (menuitem.shell) {
-          let basePath = this.kernel.path("api", name)
-          this.renderShell(basePath, indexPath, i, menuitem)
+          if (launcher_root) {
+            let basePath = this.kernel.path("api", name, launcher_root)
+            this.renderShell(basePath, indexPath, i, menuitem)
+          } else {
+            let basePath = this.kernel.path("api", name)
+            this.renderShell(basePath, indexPath, i, menuitem)
+          }
         }
 
         if (menuitem.href) {
@@ -1917,7 +1897,12 @@ class Server {
             }
           } else {
             // prototype script
-            let api_path = this.kernel.path("api", name)
+            let api_path
+            if (launcher_root) {
+              api_path = this.kernel.path("api", name, launcher_root)
+            } else {
+              api_path = this.kernel.path("api", name)
+            }
             let id = `${fullpath}?cwd=${api_path}`
             if (this.kernel.api.running[id]) {
               menuitem.running = true
@@ -1934,7 +1919,6 @@ class Server {
               let p = absolute.replace(seed, "")
               let link = p.split(/[\/\\]/).filter((x) => { return x }).join("/")
               let uri = "~/api/" + name + "/" + link
-
               config.menu[i].action.uri = uri
             }
           }
@@ -1999,7 +1983,12 @@ class Server {
               if (menuitem.image.startsWith("/")) {
                 imagePath = menuitem.image
               } else {
-                imagePath = `/api/${name}/${menuitem.image}?raw=true`
+                console.log({ launcher_root, name, image: menuitem.image })
+                if (launcher_root) {
+                  imagePath = `/api/${name}/${launcher_root}/${menuitem.image}?raw=true`
+                } else {
+                  imagePath = `/api/${name}/${menuitem.image}?raw=true`
+                }
               }
               menuitem.html = `<img class='menu-item-image' src='${imagePath}' /> ${menuitem.text}`
             } else if (menuitem.hasOwnProperty("icon")) {
@@ -2077,10 +2066,7 @@ class Server {
 //          config.icon = "/pinokio-white.png"
 //        }
 //      }
-      console.log("############## config", JSON.stringify(config, null, 2))
-
       config = Util.rewrite_localhost(this.kernel, config, req.$source)
-
       return config
     } else {
       return config
@@ -2260,12 +2246,12 @@ class Server {
 
     // 1. THEME
     this.theme = this.kernel.store.get("theme") || "light"
-    this.mode = this.kernel.store.get("mode") || "full"
+    this.mode = this.kernel.store.get("mode") || "desktop"
 
     // when loaded in electron but in minimal mode,
     // the app is loaded in the web so the agent should be "web"
     if (this.agent === "electron") {
-      if (this.mode === "minimal") {
+      if (this.mode === "minimal" || this.mode === "background") {
         this.agent = "web"
       }
     }
@@ -2504,17 +2490,70 @@ class Server {
       return true
     }
   }
-  async getPluginGlobal(req, filepath) {
+  async terminals(filepath) {
+    let venvs = await Util.find_venv(filepath)
+    let terminal
+    if (venvs.length > 0) {
+      let terminals = []
+      try {
+        for(let i=0; i<venvs.length; i++) {
+          let venv = venvs[i]
+          let parsed = path.parse(venv)
+          terminals.push(this.renderShell(filepath, i, 0, {
+            icon: "fa-brands fa-python",
+            title: "Python virtual environment",
+            subtitle: this.kernel.path("api", parsed.name),
+            text: `[venv] ${parsed.name}`,
+            type: "Start",
+            shell: {
+              venv: venv,
+              input: true,
+            }
+          }))
+        }
+      } catch (e) {
+        console.log(e)
+      }
+      terminal = {
+        icon: "fa-solid fa-terminal",
+        title: "Web Terminal",
+        subtitle: "Open the terminal in the browser",
+        menu: terminals
+      }
+    } else {
+      terminal = {
+        icon: "fa-solid fa-terminal",
+        title: "Web terminal",
+        subtitle: "Work with the terminal directly in the browser",
+        menu: [this.renderShell(filepath, 0, 0, {
+          icon: "fa-solid fa-terminal",
+          title: "Terminal",
+          subtitle: filepath,
+          text: `Terminal`,
+          type: "Start",
+          shell: {
+            input: true
+          }
+        })]
+      }
+    }
+    return terminal
+  }
+  async getPluginGlobal(req, config, terminal, filepath) {
 //    if (!this.kernel.plugin.config) {
 //      await this.kernel.plugin.init()
 //    }
-    if (this.kernel.plugin.config) {
+    if (config) {
+      
+      let c = structuredClone(config)
+      let menu = structuredClone(terminal.menu)
+      c.menu = c.menu.concat(menu)
       try {
         let info = new Info(this.kernel)
         info.cwd = () => {
           return filepath
         }
-        let menu = this.kernel.plugin.config.menu.map((item) => {
+        let menu = c.menu.map((item) => {
           return {
             params: {
               cwd: filepath
@@ -2547,34 +2586,26 @@ class Server {
       return null
     }
   }
-  async getPlugin(req, name) {
-    if (this.kernel.plugin.config) {
+  async getPlugin(req, config, name) {
+    if (config) {
+      let c = structuredClone(config)
       try {
-        if (this.kernel.plugin.cache[name]) {
-          let cached = this.kernel.plugin.cache[name]
-          return cached
-        } else {
-//          let info = new Info(this.kernel)
-//          info.caller = () => {
-//            return this.kernel.path("api", name, "pinokio.js")
-//          }
-//          let menu = await this.kernel.plugin.config.menu(this.kernel, info)
 
-          let menu = this.kernel.plugin.config.menu.map((item) => {
-            return {
-              params: {
-                //cwd: this.kernel.path("api", name, "pinokio.js")
-                cwd: this.kernel.path("api", name)
-              },
-              ...item
-            }
-          })
-          let plugin = { menu }
-          let uri = this.kernel.path("api")
-          await this.renderMenu(req, uri, name, plugin, [])
-          this.kernel.plugin.cache[name] = plugin
-          return plugin
-        }
+        let filepath = this.kernel.path("api", name)
+        let terminal = await this.terminals(filepath)
+        c.menu = c.menu.concat(terminal.menu)
+        let menu = c.menu.map((item) => {
+          return {
+            params: {
+              cwd: filepath,
+            },
+            ...item
+          }
+        })
+        let plugin = { menu }
+        let uri = this.kernel.path("api")
+        await this.renderMenu(req, uri, name, plugin, [])
+        return plugin
       } catch (e) {
         console.log("getPlugin ERROR", e)
         return null
@@ -2767,7 +2798,7 @@ class Server {
     if (this.kernel.homedir) {
       let ex = await this.kernel.exists(this.kernel.homedir, "ENVIRONMENT")
       if (!ex) {
-        let str = await Environment.ENV("system", this.kernel.homedir)
+        let str = await Environment.ENV("system", this.kernel.homedir, this.kernel)
         await fs.promises.writeFile(path.resolve(this.kernel.homedir, "ENVIRONMENT"), str)
       }
     }
@@ -2869,11 +2900,45 @@ class Server {
     this.app.use(express.static(path.resolve(__dirname, 'public')));
     this.app.use("/web", express.static(path.resolve(__dirname, "..", "..", "web")))
     this.app.set('view engine', 'ejs');
+    this.app.use((req, res, next) => {
+      let protocol = req.get('X-Forwarded-Proto') || "http"
+      req.$source = {
+        protocol,
+        host: req.get("host")
+      }
+      next()
+    })
     if (this.kernel.homedir) {
       this.app.set("views", [
         this.kernel.path("web/views"),
         path.resolve(__dirname, "views")
       ])
+      let serve = express.static(this.kernel.homedir, { fallthrough: true })
+      let http_serve = express.static(this.kernel.homedir, {
+        redirect: true,
+      })
+      let https_serve = express.static(this.kernel.homedir, {
+        redirect: false,
+      })
+      this.app.use('/asset', serve, serveIndex(this.kernel.homedir, {'icons': true}))
+      this.app.use('/asset', (req, res, next) => {
+        if (req.path.match(/\.(png|jpg|jpeg|gif|ico|svg)$/)) {
+          res.sendFile(path.resolve(__dirname, 'public', 'pinokio-black.png'));
+        } else {
+          next();
+        }
+      });
+      this.app.use("/asset", async (req, res, next) => {
+        let asset_path = this.kernel.path(req.path.slice(1), "index.html")
+        let exists = await this.exists(asset_path)
+        if (exists) {
+          return res.sendFile(asset_path)
+        } else {
+          let chunks = req.path.slice(1).split("/")
+          let parent_path = chunks.slice(0, -1).join("/")
+          res.redirect("/asset/" + parent_path)
+        }
+      })
     } else {
       this.app.set("views", [
         path.resolve(__dirname, "views")
@@ -2891,16 +2956,106 @@ class Server {
       };
       next();
     });
-    this.app.use((req, res, next) => {
-      let protocol = req.get('X-Forwarded-Proto') || "http"
-      req.$source = {
-        protocol,
-        host: req.get("host")
+    /*
+    this.app.get("/asset/*", ex((req, res) => {
+      let pathComponents = req.params[0].split("/")
+      let filepath = this.kernel.path(...pathComponents)
+      console.log("req.originalUrl", req.originalUrl)
+      console.log("pathComponents", pathComponents)
+//      if (pathComponents.length === 2 && pathComponents[0] === "api") {
+//        // ex: /asset/api/comfy.git
+//        filepath = path.resolve(filepath, "index.html")
+//      }
+      try {
+        if (req.query.frame) {
+          let m = mime.lookup(filepath)
+          res.type("text/plain")
+        }
+        //res.setHeader('Content-Disposition', 'inline');
+        res.sendFile(filepath)
+      } catch (e) {
+        res.status(404).send(e.message);
       }
-      next()
-    })
+    }))
+    */
+    this.app.get("/tools", ex(async (req, res) => {
+      let list = this.getPeers()
+      let installs = []
+      for(let key in this.kernel.bin.installed) {
+        let installed = this.kernel.bin.installed[key]
+        let modules = Array.from(installed)
+        if (modules.length > 0) {
+          installs.push({
+            package_manager: key,
+            modules,
+          })
+        }
+      }
+      // add minimal
+      const bundle_names = ["dev", "advanced_dev", "ai", "network"]
+      let bundles = []
+      let pending
+      for(let bundle_name of bundle_names) {
+        let result = await this.kernel.bin.check({
+          bin: this.kernel.bin.preset(bundle_name)
+        })
+        if (result.requirements_pending) {
+          pending = true
+        }
+        bundles.push({
+          name: bundle_name,
+          setup: "/setup/" + bundle_name + "?callback=/tools",
+          ...result
+        })
+      }
+      console.log(JSON.stringify(bundles, null, 2))
+      res.render("tools", {
+        pending,
+        installs,
+        bundles,
+        version: this.version,
+        portal: this.portal,
+        logo: this.logo,
+        theme: this.theme,
+        agent: this.agent,
+        list,
+      })
+    }))
+    this.app.get("/screenshots", ex(async (req, res) => {
+      let list = this.getPeers()
+      res.render("screenshots", {
+        version: this.version,
+        portal: this.portal,
+        logo: this.logo,
+        theme: this.theme,
+        agent: this.agent,
+        list,
+      })
+    }))
+    this.app.get("/columns", ex(async (req, res) => {
+      res.render("columns", {
+        theme: this.theme,
+        agent: this.agent,
+        src: req.get('Referrer')
+      })
+    }))
+    this.app.get("/rows", ex(async (req, res) => {
+      res.render("rows", {
+        theme: this.theme,
+        agent: this.agent,
+        src: req.get('Referrer')
+      })
+    }))
 
 
+    this.app.get("/container", ex(async (req, res) => {
+      res.render("container", {
+        theme: this.theme,
+        agent: this.agent,
+        src: req.query.url
+      })
+    }))
+
     //let home = this.kernel.homedir
     //let home = this.kernel.store.get("home")
     this.app.get("/launch", ex(async (req, res) => {
@@ -2915,7 +3070,7 @@ class Server {
       let url = req.query.url
       let u = new URL(url)
       let host = u.host
-      let env = await Environment.get(this.kernel.homedir)
+      let env = await Environment.get(this.kernel.homedir, this.kernel)
       let autolaunch = false
       if (env && env.PINOKIO_ONDEMAND_AUTOLAUNCH === "1") {
         autolaunch = true
@@ -2932,18 +3087,17 @@ class Server {
         // otherwise => redirect
 
 
-        if (chunks.length > 2) {
+        if (chunks.length >= 2) {
 
           let apipath = this.kernel.path("api")
           let files = await fs.promises.readdir(apipath, { withFileTypes: true })
-          let folders = files.filter((f) => {
-            return f.isDirectory()
-          }).map((x) => {
-            return x.name
-          })
-
-          console.log({ folders })
-            
+          let folders = []
+          for(let file of files) {
+            let type = await Util.file_type(apipath, file)
+            if (type.directory) {
+              folders.push(file.name)
+            } 
+          }
 
           let matched = false
           for(let folder of folders) {
@@ -2988,7 +3142,15 @@ class Server {
         let exists = await this.exists(api_path)
         if (exists) {
           let meta = await this.kernel.api.meta(name)
+          let launcher = await this.kernel.api.launcher(name)
+          let pinokio = launcher.script
+          let launchable = false
+          if (pinokio && pinokio.menu && pinokio.menu.length > 0) {
+            launchable = true
+          }
           res.render("start", {
+            url,
+            launchable,
             autolaunch,
             logo: this.logo,
             theme: this.theme,
@@ -3001,6 +3163,8 @@ class Server {
         }
       }
       res.render("start", {
+        url,
+        launchable: false,
         autolaunch,
         logo: this.logo,
         theme: this.theme,
@@ -3061,7 +3225,7 @@ class Server {
         }
         let system_env = {}
         if (this.kernel.homedir) {
-          system_env = await Environment.get(this.kernel.homedir)
+          system_env = await Environment.get(this.kernel.homedir, this.kernel)
         }
         let configArray = [{
           key: "home",
@@ -3083,7 +3247,7 @@ class Server {
         }, {
           key: "mode",
           val: this.mode,
-          options: ["full", "minimal"]
+          options: ["desktop", "background"]
         }, {
           key: "HTTP_PROXY",
           val: (system_env.HTTP_PROXY || ""),
@@ -3109,7 +3273,10 @@ class Server {
             drive: path.resolve(this.kernel.homedir, "drive"),
           }
         }
+        let list = this.getPeers()
         res.render("settings", {
+          current_host: this.kernel.peer.host,
+          list,
           platform,
           version: this.version,
           portal: this.portal,
@@ -3127,75 +3294,21 @@ class Server {
 
       let apipath = this.kernel.path("api")
       let files = await fs.promises.readdir(apipath, { withFileTypes: true })
-      let folders = files.filter((f) => {
-        return f.isDirectory()
-      }).map((x) => {
-        return x.name
-      })
+
+      let folders = []
+      for(let file of files) {
+        let type = await Util.file_type(apipath, file)
+        if (type.directory) {
+          folders.push(file.name)
+        } 
+      }
       let meta = {}
       for(let folder of folders) {
         meta[folder] = await this.kernel.api.meta(folder)
-//        let p = path.resolve(apipath, folder, "pinokio.js")
-//        let pinokio = (await this.kernel.loader.load(p)).resolved
-//        let p2 = path.resolve(apipath, folder, "pinokio_meta.json")
-//        let pinokio2 = (await this.kernel.loader.load(p2)).resolved
-//
-//        meta[folder] = Object.assign({}, pinokio, pinokio2)
-//        meta[folder].iconpath = meta[folder].icon ? path.resolve(apipath, folder, meta[folder].icon) : null
-//        meta[folder].icon = meta[folder].icon ? `/api/${folder}/${meta[folder].icon}?raw=true` : null
-//        meta[folder].path = path.resolve(apipath, folder)
-
-
-//        if (pinokio) {
-//          meta[folder] = {
-//            title: pinokio.title,
-//            description: pinokio.description,
-//            icon: pinokio.icon ? `/api/${folder}/${pinokio.icon}?raw=true` : null
-//          }
-//        }
-//        if (pinokio2) {
-//          if (pinokio2.title) meta[folder].title = pinokio2.title
-//          if (pinokio2.description) meta[folder].description = pinokio2.description
-//          if (pinokio2.icon) meta[folder].icon = pinokio2.icon
-//        }
       }
       await this.render(req, res, [], meta)
-//      if (this.kernel.bin.all_installed) {
-//        this.started = true
-//        let apipath = this.kernel.path("api")
-//        let files = await fs.promises.readdir(apipath, { withFileTypes: true })
-//        let folders = files.filter((f) => {
-//          return f.isDirectory()
-//        }).map((x) => {
-//          return x.name
-//        })
-//        let meta = {}
-//        for(let folder of folders) {
-//          let p = path.resolve(apipath, folder, "pinokio.js")
-//          let pinokio = (await this.kernel.loader.load(p)).resolved
-//          if (pinokio) {
-//            meta[folder] = {
-//              title: pinokio.title,
-//              description: pinokio.description,
-//              icon: pinokio.icon ? `/api/${folder}/${pinokio.icon}?raw=true` : null
-//            }
-//          }
-//        }
-//        await this.render(req, res, [], meta)
-//      } else {
-//        // get all the "start" scripts from pinokio.json
-//        // render installer page
-//        this.started = true
-//        let home = this.kernel.homedir ? this.kernel.homedir : path.resolve(os.homedir(), "pinokio")
-//        res.render("bootstrap", {
-//          home,
-//          agent: this.agent,
-//        })
-//      }
     }))
 
-//    this.app.get("/init/:name", ex(async (req, res) => {
-//      console.log("Rnder init", req.params.name)
     this.app.get("/init", ex(async (req, res) => {
       /*
         option 1: new vs. clone
@@ -3222,17 +3335,15 @@ class Server {
         return
       }
 
-//      console.log("this.kernel.proto.init")
-//      await this.kernel.proto.init()
-      let list = this.getPeerInfo()
+      let list = this.getPeers()
       let ai = await this.kernel.proto.ai()
-      ai.push({
+      ai = [{
         title: "Use your own AI recipe",
         description: "Enter your own markdown instruction for AI",
+        placeholder: "(example: 'build a launcher for https://github.com/comfyanonymous/ComfyUI)",
         meta: {},
         content: ""
-      })
-      console.log("ai", ai)
+      }].concat(ai)
       res.render("init/index", {
         list,
         ai,
@@ -3281,22 +3392,71 @@ class Server {
     - x
     */
     this.app.get("/connect", ex(async (req, res) => {
+      let list = this.getPeers()
+      let current_urls = await this.current_urls(req.originalUrl.slice(1))
+      let items = [{
+        image: "/pinokio-black.png",
+        name: "pinokio",
+        title: "pinokio.co",
+        description: "Connect with pinokio.co",
+        url: "/connect/pinokio"
+      }, {
+        icon: "fa-brands fa-square-x-twitter",
+        name: "x",
+        title: "x.com",
+        description: "Connect with X.com",
+        url: "/connect/x"
+      }, {
+        emoji: "🤗",
+        name: "huggingface",
+        title: "huggingface.co",
+        description: "Connect with huggingface.co",
+        url: "/connect/huggingface"
+      }, {
+        icon: "fa-brands fa-github",
+        name: "github",
+        title: "github.com",
+        description: "Connect with GitHub.com",
+        url: "/github"
+      }]
+      let github_hosts = await this.get_github_hosts()
+      for(let i=0; i<items.length; i++) {
+        try {
+          if (items[i].name === "github") {
+            if (github_hosts.length > 0) {
+              items[i].profile = {
+                icon: "fa-brands fa-github",
+                items: [{
+                  key: "config",
+                  val: github_hosts
+                }]
+              }
+              items[i].description = `<i class="fa-solid fa-circle-check"></i> Connected with ${items[i].title}`
+              items[i].connected = true
+            }
+          } else {
+            const config = this.kernel.connect.config[items[i].name]
+            if (config) {
+              let profile = await this.kernel.connect.profile(items[i].name)
+              if (profile) {
+                items[i].profile = profile 
+                items[i].description = `<i class="fa-solid fa-circle-check"></i> Connected with ${items[i].title}`
+                items[i].connected = true
+              }
+            }
+          }
+        } catch (e) {
+        }
+      }
       res.render(`connect`, {
+        current_urls,
+        current_host: this.kernel.peer.host,
+        list,
         portal: this.portal,
         logo: this.logo,
         theme: this.theme,
         agent: this.agent,
-        items: [{
-          icon: "fa-brands fa-square-x-twitter",
-          title: "X",
-          description: "Connect with X.com",
-          url: "/connect/x"
-        }, {
-          icon: "fa-brands fa-github",
-          title: "GitHub",
-          description: "Connect with GitHub.com",
-          url: "/github"
-        }]
+        items,
       })
     }))
     /*
@@ -3353,17 +3513,32 @@ class Server {
       }
 
 
-      let readme = await this.kernel.connect[req.params.provider].readme()
-      res.render(`connect/${req.params.provider}`, {
+      let readme = ""
+      let id = ""
+      try {
+        readme = await this.kernel.connect[req.params.provider].readme()
+        id = this.kernel.connect[req.params.provider].id
+      } catch (e) {
+      }
+      //res.render(`connect/${req.params.provider}`, {
+      const config = this.kernel.connect.config[req.params.provider]
+      res.render(`connect/index`, {
+        protocol: req.$source.protocol,
+        name: req.params.provider,
+        config,
         portal: this.portal,
         logo: this.logo,
         theme: this.theme,
         agent: this.agent,
-        id: this.kernel.connect[req.params.provider].id,
+        id,
         readme
       })
     }))
 
+    this.app.get("/connect/:provider/profile", ex(async (req, res) => {
+      let response = await this.kernel.connect.profile(req.params.provider, req.body)
+      res.send(response)
+    }))
     /*
     *  POST /connect/x/login    => login and acquire auth token
     *  POST /connect/x/logout   => loout
@@ -3548,17 +3723,8 @@ class Server {
       let md = await fs.promises.readFile(path.resolve(__dirname, "..", "kernel/connect/providers/github/README.md"), "utf8")
       let readme = marked.parse(md)
 
-      let hosts = ""
-      let hosts_file = this.kernel.path("config/gh/hosts.yml")
-      let e = await this.exists(hosts_file)
-      console.log({ hosts_file, e })
-      if (e) {
-        hosts = await fs.promises.readFile(hosts_file, "utf8")
-        console.log( { hosts: `#${hosts}#` })
-        if (hosts.startsWith("{}")) {
-          hosts = ""
-        }
-      }
+      let hosts = await this.get_github_hosts()
+
       console.log("hosts", hosts)
 
       let items
@@ -3865,8 +4031,22 @@ class Server {
         agent: this.agent,
       })
     }))
+    this.app.post("/plugin/update_spec", ex(async (req, res) => {
+      try {
+        let filepath = req.body.filepath
+        let content = req.body.spec
+        let spec_path = path.resolve(filepath, "SPEC.md")
+        await fs.promises.writeFile(spec_path, content)
+        res.json({
+          success: true
+        })
+      } catch (e) {
+        res.error({
+          error: e.stack
+        })
+      }
+    }))
     this.app.post("/plugin/update", ex(async (req, res) => {
-      console.time("/plugin/update")
       try {
         await this.kernel.exec({
           message: "git pull",
@@ -3874,7 +4054,6 @@ class Server {
         }, (e) => {
           console.log(e)
         })
-        console.timeEnd("/plugin/update")
         res.json({
           success: true
         })
@@ -3946,8 +4125,13 @@ class Server {
         }
       } catch (e) {
       }
+      console.log("PEER INFO", JSON.stringify(this.kernel.peer.info[host], null, 2))
 
       let installed = this.kernel.peer.info[host].installed
+      let serverless_mapping = this.kernel.peer.info[host].rewrite_mapping
+      let serverless = Object.keys(serverless_mapping).map((name) => {
+        return serverless_mapping[name]
+      })
       let current_urls = await this.current_urls(req.originalUrl.slice(1))
       res.render("net", {
         selected_name: req.params.name,
@@ -3959,6 +4143,7 @@ class Server {
         theme: this.theme,
         processes,
         installed,
+        serverless,
         error: null,
         list,
         host,
@@ -3996,11 +4181,11 @@ class Server {
         })
       }
 
-      if (peers.length === 0) {
-        console.log("network not yet ready")
-        res.redirect("/")
-        return
-      }
+//      if (peers.length === 0) {
+//        console.log("network not yet ready")
+//        res.redirect("/")
+//        return
+//      }
 
 
       let live_proxies = this.kernel.api.proxies["/proxy"]
@@ -4050,11 +4235,13 @@ class Server {
       // App sharing
       let apipath = this.kernel.path("api")
       let files = await fs.promises.readdir(apipath, { withFileTypes: true })
-      let folders = files.filter((f) => {
-        return f.isDirectory()
-      }).map((x) => {
-        return x.name
-      })
+      let folders = []
+      for(let file of files) {
+        let type = await Util.file_type(apipath, file)
+        if (type.directory) {
+          folders.push(file.name)
+        } 
+      }
       let apps = []
       for(let folder of folders) {
         let meta = await this.kernel.api.meta(folder)
@@ -4066,20 +4253,25 @@ class Server {
 
 
       let current_urls = await this.current_urls(req.originalUrl.slice(1))
-      let current_peer = this.kernel.peer.info[this.kernel.peer.host]
-      let host = current_peer.host
+      let current_peer = this.kernel.peer.info ? this.kernel.peer.info[this.kernel.peer.host] : null
+      let host = null
+      if (current_peer) {
+        host = current_peer.host
+      }
       let peer = current_peer
 
       let processes = []
       try {
-        processes = current_peer.router_info
-        for(let i=0; i<processes.length; i++) {
-          if (!processes[i].icon) {
-            if (protocol === "https") {
-              processes[i].icon = processes[i].https_icon
-            } else {
-              // http
-              processes[i].icon = processes[i].http_icon
+        if (current_peer) {
+          processes = current_peer.router_info
+          for(let i=0; i<processes.length; i++) {
+            if (!processes[i].icon) {
+              if (protocol === "https") {
+                processes[i].icon = processes[i].https_icon
+              } else {
+                // http
+                processes[i].icon = processes[i].http_icon
+              }
             }
           }
         }
@@ -4095,9 +4287,13 @@ class Server {
 
 
       let list = this.getPeers()
-      let installed = this.kernel.peer.info[host].installed
-      res.render("network", {
+      let installed = this.kernel.peer.info && this.kernel.peer.info[host] ? this.kernel.peer.info[host].installed : []
 
+      let static_routes = Object.keys(this.kernel.router.rewrite_mapping).map((key) => {
+        return this.kernel.router.rewrite_mapping[key]
+      })
+      res.render("network", {
+        static_routes,
         host,
         favicons,
         titles,
@@ -4137,78 +4333,16 @@ class Server {
       let str = await fs.promises.readFile(req.query.logpath, "utf8")
       res.send(str)
     }))
-    this.app.get("/state/:type/:name", ex(async (req,res) => {
-      let selected = null
-      try {
-        selected = this.selected[req.params.name][req.params.type]
-      } catch (e) {
-      }
-      res.json({
-        selected,
-      })
-    }))
-    this.app.post("/state", ex(async (req, res) => {
-      /*
-      req.body := {
-        name: <name>, 
-        type: "browse"|"run",
-        method: "toggleMenu"|"select",
-        params: {
-          <url>,
-        }
-      }
-      */
-      if (req.body.method === "select") {
-        if (!this.selected[req.body.name]) {
-          this.selected[req.body.name] = {}
-        }
-        this.selected[req.body.name][req.body.type] = req.body.params.url
-      } else if (req.body.method === "toggleMenu") {
-        if (!this.menu_hidden[req.body.name]) {
-          this.menu_hidden[req.body.name] = {}
-        }
-        if (this.menu_hidden[req.body.name][req.body.type]) {
-          this.menu_hidden[req.body.name][req.body.type] = false
-        } else {
-          this.menu_hidden[req.body.name][req.body.type] = true
-        }
-      }
-      res.json({
-        success: true
-      })
-    }))
     this.app.post("/mkdir", ex(async (req, res) => {
       let folder = req.body.folder
       let folder_path = path.resolve(this.kernel.api.userdir, req.body.folder)
       try {
         // mkdir
         await fs.promises.mkdir(folder_path)
-
-        // create basic pinokio.json
-
-        // add default icon
-
         let default_icon_path = path.resolve(__dirname, "public/pinokio-black.png")
         let icon_path = path.resolve(folder_path, "icon.png")
         await fs.promises.cp(default_icon_path, icon_path)
-
-
-        // write title/description to pinokio.json
-//        let meta_path = path.resolve(folder_path, "pinokio.json")
-//        let meta = {
-//          title: "No title",
-//          description: "",
-//          icon: "icon.png",
-//          plugin: {
-//            menu: []
-//          }
-//        }
-//        console.log({ folder_path, default_icon_path, icon_path, meta_path, meta })
-//        await fs.promises.writeFile(meta_path, JSON.stringify(meta, null, 2))
-
         res.json({
-          //success: "/pinokio/browser/"+folder
-          //success: "/p/"+folder
           success: "/init/"+folder
         })
       } catch (e) {
@@ -4291,7 +4425,7 @@ class Server {
       */
       if (req.body.type) {
         if (req.body.type === "local") {
-          let env = await Environment.get(this.kernel.homedir)
+          let env = await Environment.get(this.kernel.homedir, this.kernel)
           if (env && env.PINOKIO_SHARE_LOCAL_PORT) {
             let port = env.PINOKIO_SHARE_LOCAL_PORT.trim()
             if (port.length > 0) {
@@ -4320,244 +4454,217 @@ class Server {
         res.json({ error: "type must be 'local' or 'cloudflare'" })
       }
     }))
-    this.app.get("/prototype/run/*", ex(async (req, res) => {
-      let pathComponents = req.params[0].split("/").concat("pinokio.js")
-      let config = await this.kernel.api.meta({ path: req.query.path })
-      let pinokiojson_path = path.resolve(req.query.path, "pinokio.json")
-      let pinokiojson = await this.kernel.require(pinokiojson_path)
-      if (pinokiojson) {
-        if (pinokiojson.plugin) {
-          if (pinokiojson.plugin.menu) {
-          } else {
-            pinokiojson.plugin.menu = []
-            await fs.promises.writeFile(pinokiojson_path, JSON.stringify(pinokiojson, null, 2))
-          }
-        } else {
-          pinokiojson.plugin = { menu: [] }
-          await fs.promises.writeFile(pinokiojson_path, JSON.stringify(pinokiojson, null, 2))
-        }
-      } else {
-        pinokiojson = {
-          plugin: {
-            menu: []
-          }
-        }
-        await fs.promises.writeFile(pinokiojson_path, JSON.stringify(pinokiojson, null, 2))
-      }
-      req.base = this.kernel.path("prototype")
-      req.query.callback = config.ui
-      //req.query.callback = config.browse
-      req.query.cwd = req.query.path
-      await this.render(req, res, pathComponents, null)
-    }))
-    this.app.get("/prototype/show/*", ex(async (req, res) => {
-      let name = req.params[0].split("/").filter((x) => { return x }).join("/")
-
-      // print readme
-
-      
-
-
-      let paths = req.params[0].split("/")
-      let item
-      let config = this.kernel.proto.config
-      for(let key of paths) {
-        config = config.menu[key] 
-      }
-      console.log("config.shell", config.shell)
-      if (config.shell) {
-
-        let rendered = this.kernel.template.render(config.shell, {})
-        let params = new URLSearchParams()
-        if (rendered.path) params.set("path", encodeURIComponent(rendered.path))
-        if (rendered.message) params.set("message", encodeURIComponent(rendered.message))
-        if (rendered.venv) params.set("venv", encodeURIComponent(rendered.venv))
-        if (rendered.input) params.set("input", true)
-        if (rendered.callback) params.set("callback", encodeURIComponent(rendered.callback))
-        if (rendered.kill) params.set("kill", encodeURIComponent(rendered.kill))
-        if (rendered.done) params.set("done", encodeURIComponent(rendered.done))
-        if (rendered.env) {
-          for(let key in rendered.env) {
-            let env_key = "env." + key
-            params.set(env_key, rendered.env[key])
-          }
-        }
-        if (rendered.conda) {
-          for(let key in rendered.conda) {
-            let conda_key = "conda." + key
-            params.set(conda_key, rendered.conda[key])
-          }
-        }
-        let shell_id = Math.floor("SH_" + 1000000000000 * Math.random())
-        let href = "/shell/" + shell_id + "?" + params.toString()
-        res.redirect(href)
-      } else {
-        let run_path = "/run/prototype/system/" + config.href + "?cwd=" + req.query.path
-        let readme_path = this.kernel.path("prototype/system", config.readme)
-        let md = await fs.promises.readFile(readme_path, "utf8")
-        let baseUrl = "/asset/prototype/system/" + (config.readme.split("/").slice(0, -1).join("/")) + "/"
-        let readme = marked.parse(md, {
-          baseUrl
-        })
-        res.render("prototype/show", {
-          run_path,
-          portal: this.portal,
-          readme,
-          logo: this.logo,
-          theme: this.theme,
-          agent: this.agent,
-          kernel: this.kernel,
-        })
-      }
-
-    }))
-    this.app.get("/prototype", ex(async (req, res) => {
-      // load meta
+//    this.app.get("/prototype/run/*", ex(async (req, res) => {
+//      let pathComponents = req.params[0].split("/").concat("pinokio.js")
 //      let config = await this.kernel.api.meta({ path: req.query.path })
-//      let items = this.kernel.proto.items
-//      if (req.query.type) {
-//        items = this.kernel.proto.items.filter(item => item.type === req.query.type)
+//      let pinokiojson_path = path.resolve(req.query.path, "pinokio.json")
+//      let pinokiojson = await this.kernel.require(pinokiojson_path)
+//      if (pinokiojson) {
+//        if (pinokiojson.plugin) {
+//          if (pinokiojson.plugin.menu) {
+//          } else {
+//            pinokiojson.plugin.menu = []
+//            await fs.promises.writeFile(pinokiojson_path, JSON.stringify(pinokiojson, null, 2))
+//          }
+//        } else {
+//          pinokiojson.plugin = { menu: [] }
+//          await fs.promises.writeFile(pinokiojson_path, JSON.stringify(pinokiojson, null, 2))
+//        }
+//      } else {
+//        pinokiojson = {
+//          plugin: {
+//            menu: []
+//          }
+//        }
+//        await fs.promises.writeFile(pinokiojson_path, JSON.stringify(pinokiojson, null, 2))
 //      }
-      let title
-      let description
-      if (req.query.type === "init") {
-        title = "Initialize"
-        description = "Select an option to intitialize the project with. This may overwrite the folder if you already have existing files"
-      } else if (req.query.type === "extension") {
-        title = "Extensions"
-        description = "Add extension modules to the current folder"
-      }
-
-      let config = structuredClone(this.kernel.proto.config)
-      config = this.renderMenu2(config, {
-        cwd: req.query.path,
-        href: "/prototype/show",
-        path: this.kernel.path("prototype/system"),
-        web_path: "/asset/prototype/system"
-      })
-
-//    {
-//      "icon": "fa-solid fa-power-off",
-//      "text": "Run Default",
-//      "href": "/api/facefusion-pinokio.git/run.js?run=true&fullscreen=true&mode=Default",
-//      "params": {
-//        "run": true,
-//        "fullscreen": true,
-//        "mode": "Default"
-//      },
-//      "src": "/api/facefusion-pinokio.git/run.js",
-//      "html": "<i class=\"fa-solid fa-power-off\"></i> Run Default",
-//      "btn": "<i class=\"fa-solid fa-power-off\"></i> Run Default",
-//      "target": "@/api/facefusion-pinokio.git/run.js"
-//    },
+//      req.base = this.kernel.path("prototype")
+//      req.query.callback = config.ui
+//      //req.query.callback = config.browse
+//      req.query.cwd = req.query.path
+//      await this.render(req, res, pathComponents, null)
+//    }))
+//    this.app.get("/prototype/show/*", ex(async (req, res) => {
+//      let name = req.params[0].split("/").filter((x) => { return x }).join("/")
 //
-      res.render("prototype/index", {
-        title,
-        description,
-        config,
-        path: req.query.path,
-        portal: this.portal,
-//        items,
-        logo: this.logo,
-        platform: this.kernel.platform,
-        theme: this.theme,
-        agent: this.agent,
-        kernel: this.kernel,
-      })
-    }))
-    this.app.post("/prototype", this.upload.any(), ex(async (req, res) => {
-      try {
-        /*
-          {
-            title,
-            description,
-            path,
-            id
-          }
-        */
-        let formData = req.body
-        for(let key in req.files) {
-          let file = req.files[key]
-          formData[file.fieldname] = file.buffer
-        }
-        console.log({ formData })
-
-
-        // check if the path exists. if it does, return error
-        let api_path = this.kernel.path("api", formData.path)
-        let e = await this.exists(api_path)
-        if (e) {
-          console.log("e", e)
-          console.log("e.message", e.message)
-          res.status(500).json({ error: `The path ${api_path} already exists` })
-        } else {
-          await this.createMeta(formData)
-
-          // run 
-
-          res.json({ success: true })
-        }
-      } catch (e) {
-        console.log("e", e)
-        console.log("e.message", e.message)
-        res.status(500).json({ error: e.message })
-      }
-    }))
-    this.app.post("/new", this.upload.any(), ex(async (req, res) => {
-      try {
-        /*
-          {
-            title,
-            description,
-            path,
-            id
-          }
-        */
-        let formData = req.body
-        for(let key in req.files) {
-          let file = req.files[key]
-          formData[file.fieldname] = file.buffer
-        }
-        console.log({ formData })
-
-
-        // check if the path exists. if it does, return error
-        let api_path = this.kernel.path("api", formData.path)
-        let e = await this.exists(api_path)
-        if (e) {
-          console.log("e", e)
-          console.log("e.message", e.message)
-          res.status(500).json({ error: `The path ${api_path} already exists` })
-        } else {
-          await this.createMeta(formData)
-          res.json({ success: true })
-        }
-      } catch (e) {
-        console.log("e", e)
-        console.log("e.message", e.message)
-        res.status(500).json({ error: e.message })
-      }
-    }))
+//      // print readme
+//
+//      
+//
+//
+//      let paths = req.params[0].split("/")
+//      let item
+//      let config = this.kernel.proto.config
+//      for(let key of paths) {
+//        config = config.menu[key] 
+//      }
+//      console.log("config.shell", config.shell)
+//      if (config.shell) {
+//
+//        let rendered = this.kernel.template.render(config.shell, {})
+//        let params = new URLSearchParams()
+//        if (rendered.path) params.set("path", encodeURIComponent(rendered.path))
+//        if (rendered.message) params.set("message", encodeURIComponent(rendered.message))
+//        if (rendered.venv) params.set("venv", encodeURIComponent(rendered.venv))
+//        if (rendered.input) params.set("input", true)
+//        if (rendered.callback) params.set("callback", encodeURIComponent(rendered.callback))
+//        if (rendered.kill) params.set("kill", encodeURIComponent(rendered.kill))
+//        if (rendered.done) params.set("done", encodeURIComponent(rendered.done))
+//        if (rendered.env) {
+//          for(let key in rendered.env) {
+//            let env_key = "env." + key
+//            params.set(env_key, rendered.env[key])
+//          }
+//        }
+//        if (rendered.conda) {
+//          for(let key in rendered.conda) {
+//            let conda_key = "conda." + key
+//            params.set(conda_key, rendered.conda[key])
+//          }
+//        }
+//        let shell_id = Math.floor("SH_" + 1000000000000 * Math.random())
+//        let href = "/shell/" + shell_id + "?" + params.toString()
+//        res.redirect(href)
+//      } else {
+//        let run_path = "/run/prototype/system/" + config.href + "?cwd=" + req.query.path
+//        let readme_path = this.kernel.path("prototype/system", config.readme)
+//        let md = await fs.promises.readFile(readme_path, "utf8")
+//        let baseUrl = "/asset/prototype/system/" + (config.readme.split("/").slice(0, -1).join("/")) + "/"
+//        let readme = marked.parse(md, {
+//          baseUrl
+//        })
+//        res.render("prototype/show", {
+//          run_path,
+//          portal: this.portal,
+//          readme,
+//          logo: this.logo,
+//          theme: this.theme,
+//          agent: this.agent,
+//          kernel: this.kernel,
+//        })
+//      }
+//
+//    }))
+//    this.app.get("/prototype", ex(async (req, res) => {
+//      let title
+//      let description
+//      if (req.query.type === "init") {
+//        title = "Initialize"
+//        description = "Select an option to intitialize the project with. This may overwrite the folder if you already have existing files"
+//      } else if (req.query.type === "extension") {
+//        title = "Extensions"
+//        description = "Add extension modules to the current folder"
+//      }
+//
+//      let config = structuredClone(this.kernel.proto.config)
+//      config = this.renderMenu2(config, {
+//        cwd: req.query.path,
+//        href: "/prototype/show",
+//        path: this.kernel.path("prototype/system"),
+//        web_path: "/asset/prototype/system"
+//      })
+//      res.render("prototype/index", {
+//        title,
+//        description,
+//        config,
+//        path: req.query.path,
+//        portal: this.portal,
+//        logo: this.logo,
+//        platform: this.kernel.platform,
+//        theme: this.theme,
+//        agent: this.agent,
+//        kernel: this.kernel,
+//      })
+//    }))
+//    this.app.post("/prototype", this.upload.any(), ex(async (req, res) => {
+//      try {
+//        /*
+//          {
+//            title,
+//            description,
+//            path,
+//            id
+//          }
+//        */
+//        let formData = req.body
+//        for(let key in req.files) {
+//          let file = req.files[key]
+//          formData[file.fieldname] = file.buffer
+//        }
+//        console.log({ formData })
+//
+//
+//        // check if the path exists. if it does, return error
+//        let api_path = this.kernel.path("api", formData.path)
+//        let e = await this.exists(api_path)
+//        if (e) {
+//          console.log("e", e)
+//          console.log("e.message", e.message)
+//          res.status(500).json({ error: `The path ${api_path} already exists` })
+//        } else {
+//          await this.kernel.api.createMeta(formData)
+//
+//          // run 
+//
+//          res.json({ success: true })
+//        }
+//      } catch (e) {
+//        console.log("e", e)
+//        console.log("e.message", e.message)
+//        res.status(500).json({ error: e.message })
+//      }
+//    }))
+//    this.app.post("/new", this.upload.any(), ex(async (req, res) => {
+//      try {
+//        /*
+//          {
+//            title,
+//            description,
+//            path,
+//            id
+//          }
+//        */
+//        let formData = req.body
+//        for(let key in req.files) {
+//          let file = req.files[key]
+//          formData[file.fieldname] = file.buffer
+//        }
+//        console.log({ formData })
+//
+//
+//        // check if the path exists. if it does, return error
+//        let api_path = this.kernel.path("api", formData.path)
+//        let e = await this.exists(api_path)
+//        if (e) {
+//          console.log("e", e)
+//          console.log("e.message", e.message)
+//          res.status(500).json({ error: `The path ${api_path} already exists` })
+//        } else {
+//          await this.kernel.api.createMeta(formData)
+//          res.json({ success: true })
+//        }
+//      } catch (e) {
+//        console.log("e", e)
+//        console.log("e.message", e.message)
+//        res.status(500).json({ error: e.message })
+//      }
+//    }))
     this.app.post("/env", ex(async (req, res) => {
       let fullpath = path.resolve(this.kernel.homedir, req.body.filepath, "ENVIRONMENT")
       let updated = req.body.vals
       let hosts = req.body.hosts
-      console.log("Util.update_env", { fullpath, filepath: req.body.filepath, updated })
       await Util.update_env(fullpath, updated)
       // for all environment variables that have hosts, save the key as well
       // hosts := { env_key: host }
       for(let env in hosts) {
         let host = hosts[env]
         let val = updated[env]
-        console.log({ hosts, updated, host, val })
         await this.kernel.kv.set(host.value, val, host.index)
       }
       res.json({})
     }))
     this.app.get("/env", ex(async (req, res) => {
-      let env_path = path.resolve(this.kernel.homedir)
-      await this.init_env(env_path)
-
+      await Environment.init({}, this.kernel)
       let filepath = path.resolve(this.kernel.homedir, "ENVIRONMENT")
       let editorpath = "/edit/ENVIRONMENT"
 
@@ -4576,41 +4683,47 @@ class Server {
       })
     }))
     this.app.get("/env/*", ex(async (req, res) => {
-
       let env_path = req.params[0]
-//      let p = path.resolve(this.kernel.homedir, env_path, "pinokio.js")
-//      let config  = (await this.kernel.loader.load(p)).resolved
       let api_path
       if (env_path.startsWith("api/")) {
         api_path = env_path.slice(4) 
       }
       let config = await this.kernel.api.meta(api_path)
+      let env_result
       if (config.run) {
-        await this.init_env(env_path, { no_inherit: true })
+        env_result = await Environment.init({
+          name: api_path,
+          no_inherit: true
+        }, this.kernel)
       } else {
-        await this.init_env(env_path)
+        env_result = await Environment.init({
+          name: api_path,
+        }, this.kernel)
       }
 
-      let pathComponents = req.params[0].split("/")
-      let filepath = path.resolve(this.kernel.homedir, req.params[0], "ENVIRONMENT")
+
+      let filepath = env_result.env_path
+
+//      let pathComponents = req.params[0].split("/")
+//      let filepath = path.resolve(this.kernel.homedir, req.params[0], "ENVIRONMENT")
 
       let items = []
       let e = await this.exists(filepath)
       if (e) {
         items = await Util.parse_env_detail(filepath)
       }
-//      if (config.icon) {
-//        config.icon = `/${env_path}/${config.icon}?raw=true`
-//      } else {
-//        config.icon = "/pinokio-black.png"
-//      }
 
       let name
       if (env_path.startsWith("api")) {
         name = env_path.split("/")[1]
       }
-      let editorpath = "/edit/" + req.params[0] + "/ENVIRONMENT"
 
+      let editorpath
+      if (env_result.relpath) {
+        editorpath = "/edit/" + req.params[0] + "/" + env_result.relpath + "/ENVIRONMENT"
+      } else {
+        editorpath = "/edit/" + req.params[0] + "/ENVIRONMENT"
+      }
       if (config.run) {
         let configStr = await fs.promises.readFile(p, "utf8")
         res.render("task", {
@@ -4671,9 +4784,8 @@ class Server {
       //})
     }))
     this.app.get("/pre/api/:name", ex(async (req, res) => {
-      let p = path.resolve(this.kernel.homedir, "api", req.params.name, "pinokio.js")
-      let p2 = path.resolve(this.kernel.homedir, "api", req.params.name)
-      let config  = (await this.kernel.loader.load(p)).resolved
+      let launcher = await this.kernel.api.launcher(req.params.name)
+      let config = launcher.script
       if (config && config.pre) {
         config.pre.forEach((item) => {
           if (item.icon) {
@@ -4685,6 +4797,7 @@ class Server {
             item.href = path.resolve(this.kernel.homedir, "api", req.params.name, item.href)
           }
         })
+        let p2 = launcher.root
         let env = await Environment.get2(p2, this.kernel)
         res.render("pre", {
           name: req.params.name,
@@ -4699,8 +4812,8 @@ class Server {
       }
     }))
     this.app.get("/initialize/:name", ex(async (req, res) => {
-      let p = path.resolve(this.kernel.homedir, "api", req.params.name, "pinokio.js")
-      let config  = (await this.kernel.loader.load(p)).resolved
+      let launcher = await this.kernel.api.launcher(req.params.name)
+      let config = launcher.script
       if (config) {
         // if pinokio.js exists
         if (config.pre && Array.isArray(config.pre)) {
@@ -4817,8 +4930,8 @@ class Server {
     this.app.get("/gitcommit/:ref/*", ex(async (req, res) => {
       // return git log
       let dir = this.kernel.path("api", req.params[0])
-      let changes = []
       let d = Date.now()
+      let changes = []
       if (req.params.ref === "HEAD") {
         try {
           let statusMatrix = await git.statusMatrix({ dir, fs });
@@ -4841,6 +4954,7 @@ class Server {
                 webpath,
                 file: filepath,
                 path: fullPath,
+                diffpath: `/gitdiff/${req.params.ref}/${req.params[0]}/${filepath}`,
                 status: Util.classifyChange(head, workdir, stage),
               });
             }
@@ -4900,6 +5014,7 @@ class Server {
               webpath,
               file: filepath,
               path: fullPath,
+              diffpath: `/gitdiff/${req.params.ref}/${req.params[0]}/${filepath}`,
               status: type,
             });
           }
@@ -4907,7 +5022,8 @@ class Server {
           console.log("git diff error", err);
         }
       }
-      res.json({ changes })
+      let git_commit_url = `/run/scripts/git/commit.json?cwd=${dir}&callback_target=parent&callback=$location.href`
+      res.json({ git_commit_url, changes })
     }))
     this.app.get("/gitdiff/:ref/*", ex(async (req, res) => {
       let fullpath = this.kernel.path("api", req.params[0])
@@ -4987,6 +5103,10 @@ class Server {
       }
       res.json(response)
     }))
+    this.app.get("/info/git/:ref/*", ex(async (req, res) => {
+      let response = await this.getGit(req.params.ref, req.params[0])
+      res.json(response)
+    }))
     this.app.get("/git/:ref/*", ex(async (req, res) => {
 
       let { requirements, install_required, requirements_pending, error } = await this.kernel.bin.check({
@@ -4998,95 +5118,28 @@ class Server {
       }
 
 
-
-      let dir = this.kernel.path("api", req.params[0])
-      let branches = await git.listBranches({ fs, dir });
-      let log = []
-      try {
-        log = await git.log({ fs, dir, depth: 50, ref: req.params.ref }); // fetch last 50 commits
-      } catch (e) {
-        console.log("Log error", e)
-      }
-
-      let config = await this.kernel.git.config(dir)
-
-      let hosts = ""
-      let hosts_file = this.kernel.path("config/gh/hosts.yml")
-      let e = await this.exists(hosts_file)
-      if (e) {
-        hosts = await fs.promises.readFile(hosts_file, "utf8")
-        if (hosts.startsWith("{}")) {
-          hosts = ""
-        }
-      }
-      let connected = (hosts.length > 0)
-      let remote = null
-      if (config["remote \"origin\""]) {
-        remote = config["remote \"origin\""].url
-      }
-
-      let branch = await git.currentBranch({ fs, dir, fullname: false });
-
-      const remote2 = await git.getConfig({
-        fs,
-        dir,
-        path: `branch.${branch}.remote`
-      });
-
-      // if current branch exitss => currengt branch is selected
-      // if current branch does not exist => get logs[0].oid
-      if (branch) {
-        branches = branches.map((b) => {
-          if (b === branch) {
-            return {
-              branch: b,
-              selected: true
-            }
-          } else {
-            return {
-              branch: b,
-              selected: false
-            }
-          }
-        })
-      } else {
-        branches.push(log[0].oid)
-        branches = branches.map((b) => {
-          if (b === log[0].oid) {
-            return {
-              branch: b,
-              selected: true
-            }
-          } else {
-            return {
-              branch: b,
-              selected: false
-            }
-          }
-        })
-      }
+      let { ref, config, remote, connected, log, branch, branches, dir } = await this.getGit(req.params.ref, req.params[0])
 
       res.render("git", {
+        config,
+        remote,
+        connected,
+        log,
         branch,
         branches,
-        ref: req.params.ref,
+        ref,
         path: req.params[0],
-        log,
-        connected,
 //        changes,
         dir,
-        config,
-        remote,
         theme: this.theme,
         platform: this.kernel.platform,
         agent: this.agent,
       })
     }))
     this.app.get("/d/*", ex(async (req, res) => {
-    console.log("> 1")
       let filepath = Util.u2p(req.params[0])
-      let plugin = await this.getPluginGlobal(req, filepath)
-    console.log("> 2")
+      let terminal = await this.terminals(filepath)
+      let plugin = await this.getPluginGlobal(req, this.kernel.plugin.config, terminal, filepath)
       let html = ""
       let plugin_menu
       try {
@@ -5096,105 +5149,74 @@ class Server {
         plugin_menu = []
       }
       let current_urls = await this.current_urls(req.originalUrl.slice(1))
-    console.log("> 3")
       let retry = false
       // if plugin_menu is empty, try again in 1 sec
       if (plugin_menu.length === 0) {
         retry = true
       }
-      let venvs = await Util.find_venv(filepath)
-    console.log("> 4")
-      let terminal
-      if (venvs.length > 0) {
-        let terminals = []
-        try {
-          for(let i=0; i<venvs.length; i++) {
-            let venv = venvs[i]
-            let parsed = path.parse(venv)
-            terminals.push(this.renderShell(filepath, i, 0, {
-              icon: "fa-brands fa-python",
-              title: "Python virtual environment",
-              subtitle: this.kernel.path("api", parsed.name),
-              type: "Start",
-              shell: {
-                venv: venv,
-                input: true,
-              }
-            }))
-          }
-        } catch (e) {
-          console.log(e)
-        }
-        terminal = {
-          icon: "fa-solid fa-terminal",
-          title: "Open web terminal",
-          subtitle: "Open the terminal in the browser",
-          menu: terminals
-        }
-      } else {
-        terminal = {
-          icon: "fa-solid fa-terminal",
-          title: "Open web terminal",
-          subtitle: "Work with the terminal directly in the browser",
-          menu: [this.renderShell(filepath, 0, 0, {
-            icon: "fa-solid fa-terminal",
-            title: "Terminal",
-            subtitle: filepath,
-            type: "Start",
-            shell: {
-              input: true
-            }
-          })]
-        }
-      }
-    console.log("> 5")
 
       let exec_menus = []
       let shell_menus = []
+      let href_menus = []
       if (plugin_menu.length > 0) {
         for(let item of plugin_menu) {
           // if shell.run method exists
           // if exec method exists 
           let mode
-          for(let step of item.run) {
-            if (step.method === "exec") {
-              mode = "exec" 
-              break
+          if (item.run) {
+            for(let step of item.run) {
+              if (step.method === "exec") {
+                mode = "exec" 
+                break
+              }
+              if (step.method === "shell.run") {
+                mode = "shell"
+                break
+              }
             }
-            if (step.method === "shell.run") {
-              mode = "shell"
-              break
+            if (mode === "exec") {
+              item.type = "Open"
+              exec_menus.push(item)
+            } else if (mode === "shell") {
+              item.type = "Start"
+              shell_menus.push(item)
             }
-          }
-          if (mode === "exec") {
-            item.type = "Open"
-            exec_menus.push(item)
-          } else if (mode === "shell") {
-            item.type = "Start"
-            shell_menus.push(item)
+          } else {
+            href_menus.push(item)
           }
         }
         exec_menus.sort((a, b) => { return a > b })
         shell_menus.sort((a, b) => { return a > b })
+        href_menus.sort((a, b) => { return a > b })
       }
-    console.log("> 6")
+
+//      let terminal = await this.terminals(filepath)
+//      let online_terminal = await this.getPluginGlobal(req, terminal, filepath)
+//      console.log("online_terminal", online_terminal)
+      terminal.menus = href_menus
       let dynamic = [
         {
           icon: "fa-solid fa-robot",
-          title: "Get started building with AI",
-          subtitle: "Start making changes to this project using AI",
+          title: "AI Engineer",
+          subtitle: "Let AI work on this app",
           menu: shell_menus
         },
         {
           icon: "fa-solid fa-arrow-up-right-from-square",
-          title: "Open in external apps",
+          title: "External apps",
           subtitle: "Open this project in 3rd party apps",
           menu: exec_menus
         },
-        terminal,
+        terminal
       ]
-    console.log("> 7")
+      let spec = ""
+      try {
+        spec = await fs.promises.readFile(path.resolve(filepath, "SPEC.md"), "utf8")
+      } catch (e) {
+      }
       res.render("d", {
+        filepath,
+        spec,
         retry,
         current_urls,
         docs: this.docs,
@@ -5243,20 +5265,6 @@ class Server {
       }
       res.render("mini", result)
     }))
-    this.app.get("/asset/*", ex((req, res) => {
-      let pathComponents = req.params[0].split("/")
-      let filepath = this.kernel.path(...pathComponents)
-      try {
-        if (req.query.frame) {
-          let m = mime.lookup(filepath)
-          res.type("text/plain")
-        }
-        //res.setHeader('Content-Disposition', 'inline');
-        res.sendFile(filepath)
-      } catch (e) {
-        res.status(404).send(e.message);
-      }
-    }))
     this.app.get("/raw/*", ex((req, res) => {
       let pathComponents = req.params[0].split("/")
       let filepath = this.kernel.path("api", ...pathComponents)
@@ -5324,7 +5332,9 @@ class Server {
       }
     }))
     this.app.get("/pinokio/dynamic_global/*", ex(async (req, res) => {
-      let plugin = await this.getPluginGlobal(req, "/" + req.params[0])
+      let filepath = Util.u2p(req.params[0])
+      let terminal = await this.terminals(filepath)
+      let plugin = await this.getPluginGlobal(req, this.kernel.plugin.config, terminal, filepath)
       if (plugin) {
         let html = ""
         if (plugin && plugin.menu) {
@@ -5347,7 +5357,8 @@ class Server {
     }))
     this.app.get("/pinokio/dynamic/:name", ex(async (req, res) => {
   //    await this.kernel.plugin.init()
-      let plugin = await this.getPlugin(req, req.params.name)
+
+      let plugin = await this.getPlugin(req, this.kernel.plugin.config, req.params.name)
       let html = ""
       let plugin_menu
       if (plugin) {
@@ -5399,6 +5410,15 @@ class Server {
       })
       res.send(html)
     }))
+    this.app.get("/repos/:name", ex(async (req, res) => {
+  //    await this.kernel.plugin.init()
+      let c = this.kernel.path("api", req.params.name)
+      let repos = await this.kernel.git.repos(c)
+      let repos_with_remote = repos.filter((repo) => {
+        return repo.url
+      })
+      res.json(repos_with_remote)
+    }))
     this.app.get("/pinokio/repos/:name", ex(async (req, res) => {
   //    await this.kernel.plugin.init()
       let c = this.kernel.path("api", req.params.name)
@@ -5420,9 +5440,10 @@ class Server {
     }))
     this.app.get("/pinokio/sidebar/:name", ex(async (req, res) => {
       let name = req.params.name
-      let app_path = this.kernel.path("api", name, "pinokio.js")
+      let launcher = await this.kernel.api.launcher(name)
       let rawpath = "/api/" + name
-      let config  = (await this.kernel.loader.load(app_path)).resolved
+      let config = launcher.script
+      req.launcher_root = launcher.launcher_root
       if (config && config.menu) {
         if (typeof config.menu === "function") {
           if (config.menu.constructor.name === "AsyncFunction") {
@@ -5500,81 +5521,72 @@ class Server {
 //      await this.kernel.refresh()
 //      res.json({ success: true })
 //    }))
-    this.app.get("/pinokio/peer", ex(async (req, res) => {
-//      await this.kernel.refresh()
+
+
+    this.app.get("/info/system", ex(async (req,res) => {
       let current_peer_info = await this.kernel.peer.current_host()
       res.json(current_peer_info)
-      /*
+    }))
+    this.app.get("/info/api", ex(async (req,res) => {
+      // api related info
+      let repo = this.kernel.git.find(req.query.git)
+      if (repo) {
+        let repos = await this.kernel.git.repos(repo.path)
+        repos = repos.filter((r) => {
+          return r.main
+        })
+        let repos_with_remote = []
+        let main_repo
+        for(let repo of repos) {
+          if (repo.url) {
+            repo.commit = await this.kernel.git.getHead(repo.gitParentPath)
+            let du = await Util.du(repo.gitParentPath)
+            repo.du = du
+            repos_with_remote.push(repo)
+          }
+          if (repo.main) {
+            main_repo = repo
+          }
+        }
+        res.json({
+          repos: repos_with_remote
+        })
+      } else {
+        res.json({
+          repos: []
+        })
+      }
+    }))
+    this.app.get("/info/api/:name", ex(async (req,res) => {
+      // api related info
+      let c = this.kernel.path("api", req.params.name)
+      let repos = await this.kernel.git.repos(c)
+      let repos_with_remote = []
+      let main_repo
+      for(let repo of repos) {
+        if (repo.url) {
+          repo.commit = await this.kernel.git.getHead(repo.gitParentPath)
+          repos_with_remote.push(repo)
+        }
+        if (repo.main) {
+          main_repo = repo
+        }
+      }
       res.json({
-        home: this.kernel.homedir,
-        arch: this.kernel.arch,
-        platform: this.kernel.platform,
-        name: this.kernel.peer.name,
-        host: this.kernel.peer.host,
-        port_mapping: this.kernel.router.port_mapping,
-        //router: this.kernel.router.info(),
-        proc: this.kernel.processes.info,
-        router: this.kernel.router.published(),
-        memory: this.kernel.memory
+        repos: repos_with_remote
       })
-      */
+    }))
+
+
+    this.app.get("/pinokio/peer", ex(async (req, res) => {
+      let current_peer_info = await this.kernel.peer.current_host()
+      res.json(current_peer_info)
     }))
     this.app.get("/pinokio/memory", ex((req, res) => {
       let filepath = req.query.filepath
       let mem = this.getMemory(filepath)
       res.json(mem)
     }))
-//    this.app.post("/pinokio/tunnel", async (req, res) => {
-//      let port
-//      let local_host
-//      try {
-//        let u = new URL(req.body.url)
-//        port = u.port
-//        local_host = u.hostname
-//        console.log({ local_host, port })
-//        if (req.body.action === "start") {
-//          // Output ngrok url to console
-//
-//          let url = req.body.url
-//          console.log("tunnel", req.body)
-//          const tunnel = await ngrok.forward({ addr: port, authtoken: req.body.token });
-//          console.log("created", tunnel)
-//          console.log("url", tunnel.url())
-//          this.tunnels[url] = tunnel
-//          res.json({ url: tunnel.url() })
-//
-//
-//          // localtunnel
-//          //const tunnel = await localtunnel({ local_host, port: parseInt(port) });
-//          //const tunnel = await localtunnel({ local_host: "127.0.0.1", port: parseInt(port) });
-//
-//          //const tunnel = await localtunnel({ port: parseInt(port) });
-//          //this.tunnels[url] = tunnel
-//          //tunnel.on('error', (err) => {
-//          //  console.log(err)
-//          //  delete this.tunnels[url]
-//          //})
-//          //tunnel.on('close', () => {
-//          //  // tunnels are closed
-//          //  console.log("tunnel closed", { url, tunnel_url: tunnel.url })
-//          //  delete this.tunnels[url]
-//          //});
-//          //res.json({ url: tunnel.url })
-//        } else if (req.body.action === "stop") {
-//          let url = req.body.url
-//          await this.tunnels[url].close()
-//          delete this.tunnels[url]
-//          res.json({ url })
-////          let url = req.body.url
-////          console.log({ tunnels: this.tunnels, url })
-////          this.tunnels[url].close()
-////          res.json({ url })
-//        }
-//      } catch (e) {
-//        console.log("ERROR", e)
-//        res.json({ error: e.message })
-//      }
-//    })
     this.app.post("/pinokio/tabs", ex(async (req, res) => {
       this.tabs[req.body.name] = req.body.tabs
       res.json({ success: true })
@@ -5600,6 +5612,41 @@ class Server {
     this.app.get("/pinokio/browser/:name", ex(async (req, res) => {
       await this.chrome(req, res, "run")
     }))
+
+
+    this.app.get("/p/:name/review", ex(async (req, res) => {
+      let gitRemote = null
+      try {
+        const repositoryPath = path.resolve(this.kernel.api.userdir, req.params.name)
+        console.log({ repositoryPath })
+        gitRemote = await git.getConfig({
+          fs,
+          http,
+          dir: repositoryPath,
+          path: 'remote.origin.url'
+        })
+      } catch (e) {
+        console.log("ERROR", e)
+      }
+      let name = req.params.name
+      let run_tab = "/p/" + name
+      let dev_tab = "/p/" + name + "/dev"
+      let review_tab = "/p/" + name + "/review"
+      res.render("review", {
+        run_tab,
+        dev_tab,
+        review_tab,
+        name: req.params.name,
+        type: "review",
+        title: name,
+        url: gitRemote,
+        //redirect_uri: "http://localhost:3001/apps/redirect?git=" + gitRemote,
+        redirect_uri: "https://app-7pt7.onrender.com/apps/redirect?git=" + gitRemote,
+        platform: this.kernel.platform,
+        theme: this.theme,
+        agent: this.agent,
+      })
+    }))
     this.app.get("/p/:name/dev", ex(async (req, res) => {
       await this.chrome(req, res, "browse")
     }))
@@ -5623,7 +5670,7 @@ class Server {
           res.json({ success: true })
         } else if (req.body.type === 'env') {
           let envpath = this.kernel.path("ENVIRONMENT")
-          let str = await Environment.ENV("system", this.kernel.homedir)
+          let str = await Environment.ENV("system", this.kernel.homedir, this.kernel)
           await fs.promises.writeFile(path.resolve(this.kernel.homedir, "ENVIRONMENT"), str)
           res.json({ success: true })
         } else if (req.body.type === 'browser-cache') {
@@ -5646,35 +5693,8 @@ class Server {
         res.json({ error: err.stack })
       }
     }))
-//    this.app.get("/pinokio/shell_state", (req, res) => {
-//      let states = this.kernel.shell.shells.map((s) => {
-//        return {
-//          state: s.state,
-//          id: s.id,
-//          group: s.group,
-//          env: s.env,
-//          path: s.path,
-//          cmd: s.cmd,
-//          done: s.done,
-//          ready: s.ready,
-//        }
-//      })
-//
-//      let info = {
-//        platform: this.kernel.platform,
-//        arch: this.kernel.arch,
-//        running: this.kernel.api.running,
-//        home: this.kernel.homedir,
-//        vars: this.kernel.vars,
-//        memory: this.kernel.memory,
-//        procs: this.kernel.procs,
-//        gpu: this.kernel.gpu,
-//        gpus: this.kernel.gpus
-//      }
-//    })
     this.app.get("/pinokio/logs.zip", ex((req, res) => {
       let zipPath = this.kernel.path("logs.zip")
-      console.log("sendFile", zipPath)
       res.download(zipPath)
     }))
     this.app.post("/pinokio/log", ex(async (req, res) => {
@@ -5807,7 +5827,7 @@ class Server {
               await fs.promises.cp(old_path, new_path, { recursive: true })
 
               // 2. edit meta in the new_path
-              await this.updateMeta(formData, formData.new_path)
+              await this.kernel.api.updateMeta(formData, formData.new_path)
 
             }
           } else if (formData.move) {
@@ -5820,11 +5840,11 @@ class Server {
             }
 
             // 2. edit meta in the new_path
-            await this.updateMeta(formData, formData.new_path)
+            await this.kernel.api.updateMeta(formData, formData.new_path)
           } else {
             // 1. edit only
             if (formData.old_path === formData.new_path) {
-              await this.updateMeta(formData, formData.new_path)
+              await this.kernel.api.updateMeta(formData, formData.new_path)
             }
           }
         } else {
@@ -5888,6 +5908,56 @@ class Server {
         res.status(404).send("Missing attribute: path")
       }
     }))
+    this.app.get("/snapshots", ex(async (req, res) => {
+      let files = []
+      try {
+        files = await fs.promises.readdir(this.kernel.path("screenshots"))
+        files = files.map((file) => {
+          return `/asset/screenshots/${file}`
+        })
+      } catch (e) {
+      }
+      res.json({ files })
+    }))
+    
+    this.app.post("/snapshots", ex(async (req, res) => {
+      const { filename } = req.body
+      
+      if (!filename) {
+        return res.status(400).json({ error: "Missing filename parameter" })
+      }
+      
+      try {
+        // Extract just the filename from the path (security measure)
+        const baseFilename = path.basename(filename.replace('/asset/screenshots/', ''))
+        const fullPath = this.kernel.path("screenshots", baseFilename)
+        
+        // Check if file exists before attempting to delete
+        try {
+          await fs.promises.access(fullPath)
+        } catch (e) {
+          return res.status(404).json({ error: "File not found" })
+        }
+        
+        // Delete the file
+        await fs.promises.unlink(fullPath)
+        
+        res.json({ success: true, message: "File deleted successfully" })
+        
+      } catch (e) {
+        console.log("Error deleting screenshot:", e)
+        res.status(500).json({ error: "Failed to delete file: " + e.message })
+      }
+    }))
+    this.app.post("/screenshot", this.upload.any(), ex(async (req, res) => {
+      await fs.promises.mkdir(this.kernel.path("screenshots"), { recursive: true }).catch((e) => { })
+      for(let key in req.files) {
+        let file = req.files[key]
+        console.log({ file, key })
+        let ts = String(Date.now()) + ".png"
+        await fs.promises.writeFile(this.kernel.path("screenshots", ts), file.buffer)
+      }
+    }))
     this.app.post("/pinokio/fs", this.upload.any(), ex(async (req, res) => {
       /*
         Packet format:
@@ -6079,6 +6149,14 @@ class Server {
         res.json({ success: true })
       }
     }))
+    this.app.get("/bin_ready", ex((req, res) => {
+      if (this.kernel.bin && !this.kernel.bin.requirements_pending) {
+        res.json({ success: true })
+      } else {
+        res.json({ success: false })
+      }
+    }))
+
     this.app.get("/check", ex((req, res) => {
       res.json({ success: true })
     }))