pinokiod 3.86.0 → 3.87.0

package/server/index.js

@@ -1,4 +1,5 @@
 const express = require('express');
+const querystring = require("querystring");
 const diff = require('diff')
 const kill = require('kill-sync')
 const { isBinaryFile } = require("isbinaryfile");
@@ -199,39 +200,109 @@ class Server {
               let id = `${filepath}?cwd=${cwd}`
               obj.script_id = id
               //if (this.kernel.api.running[filepath]) {
-              if (this.kernel.api.running[id] || selected_query.plugin === obj.src) {
+              if (obj.src.startsWith("/run" + selected_query.plugin)) {
                 obj.running = true
                 obj.display = "indent"
-                if (selected_query.plugin === obj.src) {
-                  console.log("selected_query", selected_query)
-                  obj.default = true
-                  for(let key in selected_query) {
-                    if (key !== "plugin") {
-                      obj.href = obj.href + "&" + key + "=" + encodeURIComponent(selected_query[key])
-                    }
+                obj.default = true
+                for(let key in selected_query) {
+                  if (key !== "plugin") {
+                    obj.href = obj.href + "&" + key + "=" + encodeURIComponent(selected_query[key])
                   }
                 }
                 running_dynamic.push(obj)
+              } else {
+                for(let running_id in this.kernel.api.running) {
+                  if (running_id.startsWith(id)) {
+                    let obj2 = structuredClone(obj)
+                    obj2.running = true
+                    obj2.display = "indent"
+
+                    const query = running_id.split("?")[1];
+                    const params = query ? querystring.parse(query) : {};
+
+                    let queryStrippedHref = obj2.href.split("?")[0]
+                    if (params && Object.keys(params).length > 0) {
+                    obj2.href = queryStrippedHref + "?" + querystring.stringify(params)
+                  } else {
+                    obj2.href = queryStrippedHref
+                  }
+
+                  obj2.script_id = running_id
+                  obj2.target = "@" + obj2.href
+                  obj2.target_full = obj2.href
+
+                  running_dynamic.push(obj2)
+                  }
+                }
               }
             }
           } else if (key === "shell") {
+            const appendSession = (value, session) => {
+              if (!value || !session) {
+                return value
+              }
+              const hasPrefix = value.startsWith("@")
+              const raw = hasPrefix ? value.slice(1) : value
+              const [pathPart, queryPart] = raw.split("?")
+              const parsed = queryPart ? querystring.parse(queryPart) : {}
+              parsed.session = session
+              const qs = querystring.stringify(parsed)
+              const combined = qs ? `${pathPart}?${qs}` : pathPart
+              return hasPrefix ? `@${combined}` : combined
+            }
+
             let unix_path = Util.p2u(this.kernel.path("api", name))
             let shell_id = this.get_shell_id(unix_path, indexPath, obj[key])
             let decoded_shell_id = decodeURIComponent(shell_id)
             let id = "shell/" + decoded_shell_id
-            if (this.kernel.api.running[id] || selected_query.plugin === id) {
+
+            const originalHref = obj.href
+            const originalTarget = obj.target
+
+            const activeShells = (this.kernel.shell && Array.isArray(this.kernel.shell.shells))
+              ? this.kernel.shell.shells.filter((entry) => {
+                  if (!entry || !entry.id) {
+                    return false
+                  }
+                  return entry.id === id || entry.id.startsWith(`${id}?session=`)
+                })
+              : []
+
+            if (activeShells.length > 0 || selected_query.plugin === id) {
               obj.running = true
               obj.display = "indent"
               if (selected_query.plugin === id) {
                 obj.default = true
-                  console.log("selected_query", selected_query)
                 for(let key in selected_query) {
                   if (key !== "plugin") {
                     obj.href = obj.href + "&" + key + "=" + encodeURIComponent(selected_query[key])
                   }
                 }
               }
-              running_dynamic.push(obj)
+
+              if (activeShells.length === 0) {
+                running_dynamic.push(obj)
+              } else {
+                activeShells.forEach((shellEntry) => {
+                  const clone = structuredClone(obj)
+                  clone.running = true
+                  clone.display = "indent"
+                  clone.shell_id = shellEntry.id
+                  const sessionMatch = /[?&]session=([^&]+)/.exec(shellEntry.id)
+                  if (sessionMatch && sessionMatch[1]) {
+                    const sessionValue = sessionMatch[1]
+                    clone.href = appendSession(originalHref, sessionValue)
+                    const baseTarget = originalTarget || `@${originalHref}`
+                    clone.target = appendSession(baseTarget, sessionValue)
+                    clone.target_full = clone.href
+                  } else {
+                    clone.href = originalHref
+                    clone.target = originalTarget ? originalTarget : `@${clone.href}`
+                    clone.target_full = clone.href
+                  }
+                  running_dynamic.push(clone)
+                })
+              }
             }
           }
           traverse(obj[key], indexPath);
@@ -373,7 +444,6 @@ class Server {
     let p = this.kernel.path("api", name)
     let html_path = path.resolve(p, "index.html")
     let html_exists = await this.kernel.exists(html_path)
-    console.log({ html_path, html_exists })
     if (html_exists) {
       return Object.assign({
         title: name, 
@@ -381,7 +451,7 @@ class Server {
           default: true,
           icon: "fa-solid fa-link",
           text: "index.html",
-          href: "index.html?raw=true",
+          href: `/asset/api/${name}/index.html`,
         }]
       }, cfg)
     } else {
@@ -399,6 +469,20 @@ class Server {
   async getGit(ref, filepath) {
     let dir = this.kernel.path("api", filepath)
     let branches = await git.listBranches({ fs, dir });
+    // no branch, means no git repo => initialize
+    if (branches.length === 0) {
+      return {}
+//      const defaultBranch = 'main';
+//      await git.init({ fs, dir, defaultBranch });
+//      branches = await git.listBranches({ fs, dir });
+//      const current = await git.currentBranch({ fs, dir, fullname: false }) || defaultBranch;
+//      if (!branches.includes(current)) {
+//        branches.unshift(current);
+//      }
+//      if (!ref || ref === 'HEAD') {
+//        ref = current;
+//      }
+    }
     let log = []
     try {
       log = await git.log({ fs, dir, depth: 50, ref: ref }); // fetch last 50 commits
@@ -579,7 +663,6 @@ class Server {
       }
     }
 
-
     let uri = this.kernel.path("api")
     try {
       let launcher = await this.kernel.api.launcher(name)
@@ -625,30 +708,30 @@ class Server {
     }
     const env = await this.kernel.env("api/" + name)
 
-    // profile + feed
-    const repositoryPath = path.resolve(this.kernel.api.userdir, name)
-
-    try {
-      await git.resolveRef({ fs, dir: repositoryPath, ref: 'HEAD' });
-    } catch (err) {
-      // repo doesn't exist. initialize.
-      console.log(`repo doesn't exist at ${repositoryPath}. initialize`)
-      await git.init({ fs, dir: repositoryPath });
-    }
-
-    let gitRemote = await git.getConfig({ fs, http, dir: repositoryPath, path: 'remote.origin.url' })
-    let profile
-    let feed
-    if (gitRemote) {
-      gitRemote = gitRemote.replace(/\.git$/i, '')
-
-      let system_env = {}
-      if (this.kernel.homedir) {
-        system_env = await Environment.get(this.kernel.homedir, this.kernel)
-      }
-      profile = this.profile(gitRemote)
-      feed = this.newsfeed(gitRemote)
-    }
+//    // profile + feed
+//    const repositoryPath = path.resolve(this.kernel.api.userdir, name)
+//
+//    try {
+//      await git.resolveRef({ fs, dir: repositoryPath, ref: 'HEAD' });
+//    } catch (err) {
+//      // repo doesn't exist. initialize.
+//      console.log(`repo doesn't exist at ${repositoryPath}. initialize`)
+//      await git.init({ fs, dir: repositoryPath });
+//    }
+//
+//    let gitRemote = await git.getConfig({ fs, http, dir: repositoryPath, path: 'remote.origin.url' })
+//    let profile
+//    let feed
+//    if (gitRemote) {
+//      gitRemote = gitRemote.replace(/\.git$/i, '')
+//
+//      let system_env = {}
+//      if (this.kernel.homedir) {
+//        system_env = await Environment.get(this.kernel.homedir, this.kernel)
+//      }
+//      profile = this.profile(gitRemote)
+//      feed = this.newsfeed(gitRemote)
+//    }
 
     // git
 
@@ -727,8 +810,8 @@ class Server {
 //      dynamic: "/pinokio/dynamic/" + name,
       dynamic_content: null,
       name,
-      profile,
-      feed,
+//      profile,
+//      feed,
       tabs: (this.tabs[name] || []),
       config,
 //        sidebar_url: "/pinokio/sidebar/" + name,
@@ -1442,9 +1525,51 @@ class Server {
           }
           // check if there is a running process with this folder name
           let runningApps = new Set()
+          const item_path = this.kernel.path("api", items[i].name)
+          const normalizedItemPath = path.normalize(item_path)
+          const itemPathWithSep = normalizedItemPath.endsWith(path.sep)
+            ? normalizedItemPath
+            : normalizedItemPath + path.sep
+          const unix_item_path = Util.p2u(item_path)
+          const shellPrefix = "shell/" + unix_item_path + "_"
+          const matchesShell = (candidate) => {
+            if (!candidate) return false
+            const idMatches = typeof candidate.id === "string" && candidate.id.startsWith(shellPrefix)
+            const shellPath = typeof candidate.path === "string" ? path.normalize(candidate.path) : null
+            const groupPath = typeof candidate.group === "string" ? path.normalize(candidate.group) : null
+            const parentCwd = candidate.params && candidate.params.$parent && typeof candidate.params.$parent.cwd === "string"
+              ? path.normalize(candidate.params.$parent.cwd)
+              : null
+            const paramsCwd = candidate.params && typeof candidate.params.cwd === "string"
+              ? path.normalize(candidate.params.cwd)
+              : null
+            const pathMatches = shellPath && (shellPath === normalizedItemPath || shellPath.startsWith(itemPathWithSep))
+            const groupMatches = groupPath && (groupPath === normalizedItemPath || groupPath.startsWith(itemPathWithSep))
+            const parentMatches = parentCwd && (parentCwd === normalizedItemPath || parentCwd.startsWith(itemPathWithSep))
+            const paramsMatches = paramsCwd && (paramsCwd === normalizedItemPath || paramsCwd.startsWith(itemPathWithSep))
+            return idMatches || pathMatches || groupMatches || parentMatches || paramsMatches
+          }
+          const shellMatches = (this.kernel.shell && typeof this.kernel.shell.find === "function")
+            ? this.kernel.shell.find({ filter: matchesShell })
+            : []
+          const addShellEntries = () => {
+            if (!shellMatches || shellMatches.length === 0) {
+              return
+            }
+            if (!items[i].running_scripts) {
+              items[i].running_scripts = []
+            }
+            for (const sh of shellMatches) {
+              if (!sh || !sh.id) continue
+              const exists = items[i].running_scripts.some((entry) => entry && entry.id === sh.id)
+              if (!exists) {
+                items[i].running_scripts.push({ id: sh.id, name: sh.params.$title || "Shell", type: "shell" })
+              }
+            }
+          }
           for(let key in this.kernel.api.running) {
             //let p = this.kernel.path("api", items[i].name) + path.sep
-            let p = this.kernel.path("api", items[i].name)
+            let p = item_path
 
             // not only should include the pattern, but also end with it (otherwise can include similar patterns such as /api/qqqa, /api/qqqaaa, etc.
 
@@ -1468,7 +1593,6 @@ class Server {
                   if (chunks.length > 1) {
                     let folder = chunks[0]
                     /// if the folder name matches, it's running
-                    let item_path = this.kernel.path("api", items[i].name)
                     if (item_path === folder) {
                       is_running = true
                     }
@@ -1485,12 +1609,15 @@ class Server {
             //if (key.includes(p) && key.endsWith(p)) {
             if (is_running) {
               // add to running
-              running.push(items[i]) 
+              if (!items[i].running) {
+                running.push(items[i])
+                items[i].running = true
+                items[i].index = index
+                index++
+              }
               if (!items[i].running_scripts) {
                 items[i].running_scripts = []
               }
-              items[i].running = true
-              items[i].index = index
 
               // add the running script to running_scripts array
               // 1. normal api script
@@ -1511,24 +1638,17 @@ class Server {
                   items[i].running_scripts.push({ id: key, name })
                 }
               } else {
-                let shell = this.kernel.shell.find({
-                  filter: (shell) => {
-                    let item_path = this.kernel.path("api", items[i].name)
-                    let unix_item_path = Util.p2u(item_path)
-                    return shell.id.startsWith("shell/" + unix_item_path + "_")
-                  }
-                })
-                if (shell.length > 0) {
-                  items[i].running = true
-                  items[i].index = index
-                  for(let sh of shell) {
-                    items[i].running_scripts.push({ id: sh.id, name: "Terminal", type: "shell" })
-                  }
-                }
+                addShellEntries()
               }
-              index++;
             }
           }
+          if (!items[i].running && shellMatches && shellMatches.length > 0) {
+            running.push(items[i])
+            items[i].running = true
+            items[i].index = index
+            addShellEntries()
+            index++
+          }
           if (!items[i].running) {
             items[i].index = index
             index++;
@@ -1874,15 +1994,19 @@ class Server {
 //          }
       menuitem.href = "/shell/" + shell_id + "?" + params.toString()
       let decoded_shell_id = decodeURIComponent(shell_id)
-      let shell = this.kernel.shell.get(decoded_shell_id)
-      menuitem.shell_id = "shell/" + decoded_shell_id
+      const shellPrefixId = "shell/" + decoded_shell_id
+      let shell = this.kernel.shell.get(shellPrefixId)
+      if (!shell && this.kernel.shell && Array.isArray(this.kernel.shell.shells)) {
+        shell = this.kernel.shell.shells.find((entry) => {
+          if (!entry || !entry.id) {
+            return false
+          }
+          return entry.id === shellPrefixId || entry.id.startsWith(`${shellPrefixId}?session=`)
+        })
+      }
+      menuitem.shell_id = shellPrefixId
       if (shell) {
         menuitem.running = true
-      } else {
-        let shell = this.kernel.shell.get(decoded_shell_id)
-        if (shell) {
-          menuitem.running = true
-        }
       }
     }
     return menuitem
@@ -2001,10 +2125,11 @@ class Server {
           } else if (menuitem.href.startsWith("/")) {
             let run_path = "/run"
             if (menuitem.href.startsWith(run_path)) {
-              u = new URL("http://localhost" + menuitem.href.slice(run_path.length))
-              cwd = u.searchParams.get("cwd")
-              u.search = ""
-              menuitem.src = u.pathname
+              menuitem.src = menuitem.href
+//              u = new URL("http://localhost" + menuitem.href.slice(run_path.length))
+//              cwd = u.searchParams.get("cwd")
+//              u.search = ""
+//              menuitem.src = u.pathname
             } else {
               u = new URL("http://localhost" + menuitem.href)
               cwd = u.searchParams.get("cwd")
@@ -2143,16 +2268,19 @@ class Server {
         if (config.menu[i].popout) {
           config.menu[i].target = "_blank"
         } else {
-          config.menu[i].target = "@" + (config.menu[i].id || config.menu[i].src)
-        }
-
-
-        if (config.menu[i].href && config.menu[i].href.startsWith("http")) {
-          if (req.agent !== "electron") {
-            config.menu[i].target = "_blank"
+          const targetBase = config.menu[i].id || config.menu[i].src || config.menu[i].href
+          config.menu[i].target = targetBase ? "@" + targetBase : undefined
+          if (config.menu[i].href) {
+            config.menu[i].target_full = config.menu[i].href
           }
         }
 
+        //if (config.menu[i].href && config.menu[i].href.startsWith("http")) {
+        //  if (req.agent !== "electron") {
+        //    config.menu[i].target = "_blank"
+        //  }
+        //}
+
         if (menuitem.shell_id) {
           config.menu[i].shell_id = menuitem.shell_id
         }
@@ -2478,7 +2606,7 @@ class Server {
 //    }
   }
   async setConfig(config) {
-    let home = this.kernel.store.get("home")
+    let home = this.kernel.store.get("home") || process.env.PINOKIO_HOME
     let theme = this.kernel.store.get("theme")
     let mode = this.kernel.store.get("mode")
 //    let drive = this.kernel.store.get("drive")
@@ -2543,9 +2671,9 @@ class Server {
 //    }
 
 
-    home = this.kernel.store.get("home")
+    home = this.kernel.store.get("home") || process.env.PINOKIO_HOME
     theme = this.kernel.store.get("theme")
-    let new_home = this.kernel.store.get("new_home")
+    let new_home = this.kernel.store.get("new_home") || process.env.PINOKIO_HOME
 
     // Handle environment variables
     // HTTP_PROXY
@@ -2618,6 +2746,66 @@ class Server {
       return true
     }
   }
+  add_extra_urls(info) {
+    // get only the parts not from this peer
+    for(let host in this.kernel.peer.info) {
+      let host_info = this.kernel.peer.info[host]
+
+      let host_rewrites = host_info.rewrite_mapping
+      for(let key in host_rewrites) {
+        info.push({
+          online: true,
+          host: {
+            ip: host,
+            local: this.kernel.peer.host === host,
+            name: host_info.name,
+            platform: host_info.platform,
+            arch: host_info.arch
+          },
+          name: `[Files] ${host_rewrites[key].name}`,
+          ip: host_rewrites[key].external_ip
+        })
+      }
+      if (this.kernel.peer.host !== host) {
+        let host_routers = host_info.router_info
+        for(let host_router of host_routers) {
+          let ip
+          // the peer sharing works only if external_ip is available (caddy is installed)
+          if (host_router.external_ip) {
+            ip = host_router.external_ip
+          } else {
+            // if caddy is not turned on, set ip as null, so that it suggests turning on peer sharing
+            ip = null
+          }
+          info.push({
+            online: true,
+            host: {
+              ip: host,
+              name: host_info.name,
+              platform: host_info.platform,
+              arch: host_info.arch
+            },
+            name: host_router.title || host_router.name,
+            ip
+          })
+        }
+      }
+
+      for(let app of host_info.installed) {
+        info.push({
+          host: {
+            ip: host,
+            local: this.kernel.peer.host === host,
+            name: host_info.name,
+            platform: host_info.platform,
+            arch: host_info.arch
+          },
+          name: app.title || app.folder,
+          ip: app.http_href.replace("http://", "")
+        })
+      }
+    }
+  }
   async terminals(filepath) {
     let venvs = await Util.find_venv(filepath)
     let terminal
@@ -2644,14 +2832,14 @@ class Server {
       }
       terminal = {
         icon: "fa-solid fa-terminal",
-        title: "Web Terminal",
+        title: "Terminal",
         subtitle: "Open the terminal in the browser",
         menu: terminals
       }
     } else {
       terminal = {
         icon: "fa-solid fa-terminal",
-        title: "Web terminal",
+        title: "Terminal",
         subtitle: "Work with the terminal directly in the browser",
         menu: [this.renderShell(filepath, 0, 0, {
           icon: "fa-solid fa-terminal",
@@ -2833,7 +3021,7 @@ class Server {
     await this.syncConfig()
 
     try {
-      let _home = this.kernel.store.get("home")
+      let _home = this.kernel.store.get("home") || process.env.PINOKIO_HOME
       if (_home) {
         await this.startLogging(_home)
       }
@@ -2869,7 +3057,7 @@ class Server {
     }
 
     let version = this.kernel.store.get("version")
-    let home = this.kernel.store.get("home")
+    let home = this.kernel.store.get("home") || process.env.PINOKIO_HOME
 
     let needInitHome = false
     if (home) {
@@ -3181,17 +3369,25 @@ class Server {
       })
     }))
     this.app.get("/columns", ex(async (req, res) => {
+      const originSrc = req.query.origin || req.get('Referrer') || '/';
+      const targetSrc = req.query.target || originSrc;
       res.render("columns", {
         theme: this.theme,
         agent: req.agent,
-        src: req.get('Referrer')
+        originSrc,
+        targetSrc,
+        src: originSrc
       })
     }))
     this.app.get("/rows", ex(async (req, res) => {
+      const originSrc = req.query.origin || req.get('Referrer') || '/';
+      const targetSrc = req.query.target || originSrc;
       res.render("rows", {
         theme: this.theme,
         agent: req.agent,
-        src: req.get('Referrer')
+        originSrc,
+        targetSrc,
+        src: originSrc
       })
     }))
 
@@ -3333,7 +3529,7 @@ class Server {
         link: null
       })
     }))
-    this.app.get("/", ex(async (req, res) => {
+    const renderHomePage = ex(async (req, res) => {
       // check bin folder
 //      let bin_path = this.kernel.path("bin/miniconda")
 //      let bin_exists = await this.exists(bin_path)
@@ -3350,7 +3546,7 @@ class Server {
 //      }
 
       if (req.query.mode !== "settings" && !home) {
-        res.redirect("/?mode=settings")
+        res.redirect("/home?mode=settings")
         return
       }
       if (req.query.mode === "help") {
@@ -3372,7 +3568,6 @@ class Server {
         return
       }
 
-
       if (req.query.mode === 'settings') {
 
         let platform = os.platform()
@@ -3393,7 +3588,7 @@ class Server {
             "* NO exFAT drives",
           ],
           val: this.kernel.homedir ? this.kernel.homedir : _home,
-          placeholder: "Enter the absolute path to use as your Pinokio home folder (D:\\pinokio, /Users/alice/pinokiofs, etc.)"
+          placeholder: "Enter the absolute path to use as your Pinokio home folder (D\\pinokio, /Users/alice/pinokiofs, etc.)"
 //        }, {
 //          key: "drive",
 //          val: path.resolve(this.kernel.homedir, "drive"),
@@ -3466,6 +3661,58 @@ class Server {
         meta[folder] = await this.kernel.api.meta(folder)
       }
       await this.render(req, res, [], meta)
+    })
+
+    this.app.get("/", ex(async (req, res) => {
+      const protocol = (req.$source && req.$source.protocol) || req.protocol || 'http'
+      const host = req.get('host') || `localhost:${this.port}`
+      const baseUrl = `${protocol}://${host}`
+
+      const initialUrl = new URL('/home', baseUrl)
+      const defaultUrl = new URL('/home', baseUrl)
+
+      for (const [key, value] of Object.entries(req.query)) {
+        if (key === 'session') {
+          continue
+        }
+        if (Array.isArray(value)) {
+          value.forEach((val) => {
+            initialUrl.searchParams.append(key, val)
+          })
+        } else if (value != null) {
+          initialUrl.searchParams.set(key, value)
+        }
+      }
+
+      if (!home) {
+        defaultUrl.searchParams.set('mode', 'settings')
+      }
+
+      res.render('layout', {
+        theme: this.theme,
+        agent: req.agent,
+        initialPath: initialUrl.pathname + initialUrl.search + initialUrl.hash,
+        defaultPath: defaultUrl.pathname + defaultUrl.search + defaultUrl.hash,
+        sessionId: typeof req.query.session === 'string' ? req.query.session : null
+      })
+    }))
+
+    this.app.get("/home", renderHomePage)
+
+
+    this.app.get("/bundle/:name", ex(async (req, res) => {
+      let { requirements, install_required, requirements_pending, error } = await this.kernel.bin.check({
+        bin: this.kernel.bin.preset(req.params.name),
+      })
+      if (!requirements_pending && install_required) {
+        res.json({
+          available: false,
+        })
+      } else {
+        res.json({
+          available: true,
+        })
+      }
     }))
 
     this.app.get("/init", ex(async (req, res) => {
@@ -4038,7 +4285,12 @@ class Server {
       GET /shell/:unix_path => shell id: 'shell/:unix_path'
       */
 
-      let id = "shell/" + decodeURIComponent(req.params.id)
+      let baseShellId = "shell/" + decodeURIComponent(req.params.id)
+      const sessionId = typeof req.query.session === "string" && req.query.session.length > 0 ? req.query.session : null
+      let id = baseShellId
+      if (sessionId) {
+        id = `${baseShellId}?session=${sessionId}`
+      }
       let target = req.query.target ? req.query.target : null
       let cwd = this.kernel.path(this.kernel.api.filePath(decodeURIComponent(req.query.path)))
       let message = req.query.message ? decodeURIComponent(req.query.message) : null
@@ -4304,7 +4556,11 @@ class Server {
         return serverless_mapping[name]
       })
       let current_urls = await this.current_urls(req.originalUrl.slice(1))
+      let static_routes = Object.keys(this.kernel.router.rewrite_mapping).map((key) => {
+        return this.kernel.router.rewrite_mapping[key]
+      })
       res.render("net", {
+        static_routes,
         selected_name: req.params.name,
         current_urls,
         docs: this.docs,
@@ -4821,6 +5077,7 @@ class Server {
 //    }))
     this.app.post("/env", ex(async (req, res) => {
       let fullpath = path.resolve(this.kernel.homedir, req.body.filepath, "ENVIRONMENT")
+      console.log({ fullpath })
       let updated = req.body.vals
       let hosts = req.body.hosts
       await Util.update_env(fullpath, updated)
@@ -5128,7 +5385,7 @@ class Server {
             }
           }
         } catch (err) {
-          console.log("git status matrix error", err)
+//          console.log("git status matrix error 1", err)
         }
       } else {
         try {
@@ -5187,7 +5444,7 @@ class Server {
             });
           }
         } catch (err) {
-          console.log("git diff error", err);
+          console.log("git diff error 2", err);
         }
       }
       let git_commit_url = `/run/scripts/git/commit.json?cwd=${dir}&callback_target=parent&callback=$location.href`
@@ -5286,22 +5543,15 @@ class Server {
       }
 
 
-      let { ref, config, remote, connected, log, branch, branches, dir } = await this.getGit(req.params.ref, req.params[0])
+      let response = await this.getGit(req.params.ref, req.params[0])
 
       res.render("git", {
-        config,
-        remote,
-        connected,
-        log,
-        branch,
-        branches,
-        ref,
         path: req.params[0],
 //        changes,
-        dir,
         theme: this.theme,
         platform: this.kernel.platform,
         agent: req.agent,
+        ...response
       })
     }))
     this.app.get("/d/*", ex(async (req, res) => {
@@ -5363,9 +5613,10 @@ class Server {
 //      console.log("online_terminal", online_terminal)
       terminal.menus = href_menus
       let dynamic = [
+        terminal,
         {
           icon: "fa-solid fa-robot",
-          title: "AI Engineer",
+          title: "AI Terminal",
           subtitle: "Let AI work on this app",
           menu: shell_menus
         },
@@ -5375,7 +5626,6 @@ class Server {
           subtitle: "Open this project in 3rd party apps",
           menu: exec_menus
         },
-        terminal
       ]
       let spec = ""
       try {
@@ -5669,12 +5919,122 @@ class Server {
 //      res.json({ success: true })
 //    }))
 
+
+    this.app.get("/info/scripts", ex(async (req, res) => {
+    /*
+      returns something like this by using the this.kernel.memory.local variable, extracting the api name and adding all running scripts in each associated array, setting the uri as the script path, and the local variables as the local attribute
+      the api name in the following examples are "comfyui" and "gradio", therefore there are two top level attributes "comfyui" and "gradio", each of which has an array value made up of all scripts running under that api
+      {
+        “comfyui”: [{
+          “uri”: “/data/pinokio/api/comfyui/start.js”,
+          “local”: {
+              "port": 42008,
+              "url": "http://127.0.0.1:42008"	
+          }
+        }],
+        “gradio”: [{
+          “uri”: “/data/pinokio/api/gradio/start.js”,
+          “local”: {
+              "port": 7860,
+              "url": "http://127.0.0.1:7860"
+          }
+        }]
+      }
+      */
+      if (!this.kernel || !this.kernel.info || typeof this.kernel.info.scriptsByApi !== 'function') {
+        res.json({})
+        return
+      }
+
+      const scriptsByApi = this.kernel.info.scriptsByApi()
+      res.json(scriptsByApi)
+    }))
+    this.app.get("/info/local", ex(async (req, res) => {
+      if (this.kernel && this.kernel.memory && this.kernel.memory.local) {
+        res.json(this.kernel.memory.local)
+      } else {
+        res.json({})
+      }
+    }))
+
+
     this.app.get("/info/procs", ex(async (req, res) => {
       await this.kernel.processes.refresh()
 
-      let info = []
-      for(let item of this.kernel.processes.info) {
-        info.push({
+      const requestedProtocol = ((req.$source && req.$source.protocol) || req.protocol || '').toLowerCase()
+      const preferHttps = requestedProtocol === 'https'
+
+      const routerInfo = (preferHttps && this.kernel.router && this.kernel.router.info && this.kernel.peer)
+        ? (this.kernel.router.info[this.kernel.peer.host] || {})
+        : null
+
+      const resolveHttpsHosts = (proc) => {
+        if (!routerInfo) {
+          return []
+        }
+        const possibleKeys = new Set()
+        if (proc.ip) {
+          possibleKeys.add(proc.ip)
+        }
+        if (proc.port) {
+          possibleKeys.add(`127.0.0.1:${proc.port}`)
+          possibleKeys.add(`localhost:${proc.port}`)
+          possibleKeys.add(`0.0.0.0:${proc.port}`)
+        }
+
+        const hosts = new Set()
+        for (const key of possibleKeys) {
+          const matches = routerInfo[key]
+          if (!matches || matches.length === 0) {
+            continue
+          }
+          for (const match of matches) {
+            if (typeof match === 'string' && match.trim().length > 0) {
+              hosts.add(match.trim())
+            }
+          }
+        }
+        return Array.from(hosts)
+      }
+
+      const preferFriendlyHost = (hosts) => {
+        if (!hosts || hosts.length === 0) {
+          return null
+        }
+        for (const host of hosts) {
+          if (!/^\d+\.localhost$/i.test(host)) {
+            return host
+          }
+        }
+        return hosts[0]
+      }
+
+      const info = this.kernel.processes.info.map((item) => {
+        const httpUrl = item.ip ? `http://${item.ip}` : null
+        let httpsHosts = []
+        if (preferHttps) {
+          httpsHosts = resolveHttpsHosts(item)
+        }
+        const httpsUrls = httpsHosts.map((host) => {
+          if (!host) {
+            return null
+          }
+          const trimmed = host.trim()
+          if (/^https?:\/\//i.test(trimmed)) {
+            return trimmed.replace(/^http:\/\//i, 'https://')
+          }
+          return `https://${trimmed}`
+        }).filter(Boolean)
+
+        const preferredHttpsUrl = preferFriendlyHost(httpsHosts)
+        const displayHttpsUrl = preferredHttpsUrl
+          ? (preferredHttpsUrl.startsWith('http') ? preferredHttpsUrl.replace(/^http:/i, 'https:') : `https://${preferredHttpsUrl}`)
+          : (httpsUrls[0] || null)
+
+        const selectedUrl = (preferHttps && displayHttpsUrl) ? displayHttpsUrl : httpUrl
+        const protocol = (preferHttps && displayHttpsUrl) ? 'https' : 'http'
+
+        return {
           online: true,
           host: {
             ip: this.kernel.peer.host,
@@ -5684,65 +6044,16 @@ class Server {
             arch: this.kernel.arch,
           },
           ...item,
-        })
-      }
-      // get only the parts not from this peer
-      for(let host in this.kernel.peer.info) {
-        let host_info = this.kernel.peer.info[host]
-        let host_rewrites = host_info.rewrite_mapping
-        for(let key in host_rewrites) {
-          info.push({
-            online: true,
-            host: {
-              ip: host,
-              local: this.kernel.peer.host === host,
-              name: host_info.name,
-              platform: host_info.platform,
-              arch: host_info.arch
-            },
-            name: `[Files] ${host_rewrites[key].name}`,
-            ip: host_rewrites[key].external_ip
-          })
-        }
-        if (this.kernel.peer.host !== host) {
-          let host_routers = host_info.router_info
-          for(let host_router of host_routers) {
-            let ip
-            // the peer sharing works only if external_ip is available (caddy is installed)
-            if (host_router.external_ip) {
-              ip = host_router.external_ip
-            } else {
-              // if caddy is not turned on, set ip as null, so that it suggests turning on peer sharing
-              ip = null
-            }
-            info.push({
-              online: true,
-              host: {
-                ip: host,
-                name: host_info.name,
-                platform: host_info.platform,
-                arch: host_info.arch
-              },
-              name: host_router.title || host_router.name,
-              ip
-            })
+          url: selectedUrl,
+          protocol,
+          urls: {
+            http: httpUrl,
+            https: httpsUrls
           }
         }
+      })
 
-        for(let app of host_info.installed) {
-          info.push({
-            host: {
-              ip: host,
-              local: this.kernel.peer.host === host,
-              name: host_info.name,
-              platform: host_info.platform,
-              arch: host_info.arch
-            },
-            name: app.title || app.folder,
-            ip: app.http_href.replace("http://", "")
-          })
-        }
-      }
+//      this.add_extra_urls(info)
       res.json({
         info
       })
@@ -5782,6 +6093,10 @@ class Server {
         })
       }
     }))
+    this.app.get("/info/shells", ex(async (req,res) => {
+      let shells = this.kernel.shell.info()
+      res.json(shells)
+    }))
     this.app.get("/info/api/:name", ex(async (req,res) => {
       // api related info
       let c = this.kernel.path("api", req.params.name)
@@ -5865,7 +6180,7 @@ class Server {
         title: name,
         url: gitRemote,
         //redirect_uri: "http://localhost:3001/apps/redirect?git=" + gitRemote,
-        redirect_uri: "https://app-7pt7.onrender.com/apps/redirect?git=" + gitRemote,
+        redirect_uri: "https://app.pinokio.co/apps/redirect?git=" + gitRemote,
         platform: this.kernel.platform,
         theme: this.theme,
         agent: req.agent,
@@ -5987,7 +6302,7 @@ class Server {
     }))
     this.app.get("/pinokio/download", ex((req, res) => {
       let queryStr = new URLSearchParams(req.query).toString()
-      res.redirect("/?mode=download&" + queryStr)
+      res.redirect("/home?mode=download&" + queryStr)
     }))
     this.app.post("/pinokio/install", ex((req, res) => {
       req.session.requirements = req.body.requirements
@@ -6131,6 +6446,31 @@ class Server {
         res.status(404).send("Missing attribute: path")
       }
     }))
+    const ensureCaptureDir = async () => {
+      await fs.promises.mkdir(this.kernel.path("screenshots"), { recursive: true }).catch(() => {});
+    };
+
+    const saveCaptureFiles = async (files, fallbackExt = '.png') => {
+      await ensureCaptureDir();
+      const saved = [];
+      if (Array.isArray(files)) {
+        for (const file of files) {
+          if (!file || !file.buffer) continue;
+          const origName = file.originalname || '';
+          let ext = path.extname(origName);
+          if (!ext && file.mimetype) {
+            const mapped = mime.extension(file.mimetype);
+            if (mapped) ext = `.${mapped}`;
+          }
+          if (!ext) ext = fallbackExt;
+          const name = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`;
+          await fs.promises.writeFile(this.kernel.path("screenshots", name), file.buffer);
+          saved.push({ name, url: `/asset/screenshots/${name}` });
+        }
+      }
+      return saved;
+    };
+
     this.app.get("/snapshots", ex(async (req, res) => {
       let files = []
       try {
@@ -6172,13 +6512,13 @@ class Server {
         res.status(500).json({ error: "Failed to delete file: " + e.message })
       }
     }))
+    this.app.post("/capture", this.upload.any(), ex(async (req, res) => {
+      const saved = await saveCaptureFiles(req.files);
+      res.json({ saved });
+    }))
     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]
-        let ts = String(Date.now()) + ".png"
-        await fs.promises.writeFile(this.kernel.path("screenshots", ts), file.buffer)
-      }
+      const saved = await saveCaptureFiles(req.files);
+      res.json({ saved });
     }))
     this.app.post("/pinokio/fs", this.upload.any(), ex(async (req, res) => {
       /*
@@ -6360,7 +6700,7 @@ class Server {
           ready = false;
         }
         if (ready) {
-          res.json({ success: true })
+          res.json({ success: true, peer_name: this.kernel.peer.name  })
         } else {
           res.json({ success: false })
         }