pinokiod 3.148.0 → 3.151.0

package/kernel/prototype.js

@@ -75,7 +75,6 @@ class Proto {
     await fs.promises.rm(this.kernel.path("prototype"), { recursive: true })
   }
   async create(req, ondata) {
-    console.log("CREATE", req)
     try {
       if (req.client) {
         this.kernel.client = req.client

package/kernel/router/common.js

@@ -11,6 +11,7 @@ class Common extends Processor {
       "headers": {
         "request": {
           "set": {
+            "Host": ["{http.request.host}"],
             "X-Forwarded-Proto": ["https"],
             "X-Forwarded-Host": ["{http.request.host}"]
           }

package/kernel/router/connector.js

@@ -16,6 +16,7 @@ class Connector extends Processor {
       "headers": {
         "request": {
           "set": {
+            "Host": ["{http.request.header.X-Forwarded-Host}"],
             "X-Forwarded-Proto": ["{http.request.header.X-Forwarded-Proto}"],
             //"X-Forwarded-Proto": ["{http.request.scheme}"],
             //"X-Forwarded-Proto": ["https"],
@@ -55,6 +56,7 @@ class Connector extends Processor {
           "headers": {
             "request": {
               "set": {
+                "Host": ["{http.request.host}"],
                 //"X-Forwarded-Proto": ["https"],
                 //"Origin": "localhost",
                 "X-Forwarded-Proto": ["{http.request.scheme}"],

package/kernel/shell.js

@@ -1061,20 +1061,20 @@ class Shell {
             this.monitor = this.monitor + data
             this.monitor = this.monitor.slice(-300) // last 300
 
-            let notifications = this.parser.processData(data)
-            if (notifications.length > 0) {
-              console.log({ notifications })
-              for(let notif of notifications) {
-                if (notif.type !== "bell") {
-                  Util.push({
-                    image: path.resolve(__dirname, "../server/public/pinokio-black.png"),
-                    message: notif.title,
-                    sound: true,
-                    timeout: 30,
-                  })
-                }
-              }
-            }
+//            let notifications = this.parser.processData(data)
+//            if (notifications.length > 0) {
+//              console.log({ notifications })
+//              for(let notif of notifications) {
+//                if (notif.type !== "bell") {
+//                  Util.push({
+//                    image: path.resolve(__dirname, "../server/public/pinokio-black.png"),
+//                    message: notif.title,
+//                    sound: true,
+//                    timeout: 30,
+//                  })
+//                }
+//              }
+//            }
 
             if (!this.done) {
 

package/kernel/util.js

@@ -711,7 +711,6 @@ function push(params) {
 
   emitPushEvent(eventPayload)
 
-  console.log("notifyParams", notifyParams)
   notifier.notify(notifyParams)
 }
 function p2u(localPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "3.148.0",
+  "version": "3.151.0",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/index.js

@@ -25,6 +25,7 @@ const QRCode = require('qrcode')
 const axios = require('axios')
 const crypto = require('crypto')
 const serveIndex = require('./serveIndex')
+const registerFileRoutes = require('./routes/files')
 
 const git = require('isomorphic-git')
 const http = require('isomorphic-git/http/node')
@@ -812,6 +813,12 @@ class Server {
     let dev_tab = "/p/" + name + "/dev"
     let review_tab = "/p/" + name + "/review"
 
+    let editor_tab = `/pinokio/fileview/${encodeURIComponent(name)}`
+    let savedTabs = []
+    if (Array.isArray(this.tabs[name])) {
+      savedTabs = this.tabs[name].filter((url) => url !== editor_tab)
+    }
+
     let dynamic_url = "/pinokio/dynamic/" + name;
     if (Object.values(req.query).length > 0) {
       let index = 0
@@ -852,7 +859,8 @@ class Server {
       name,
 //      profile,
 //      feed,
-      tabs: (this.tabs[name] || []),
+      tabs: savedTabs,
+      editor_tab: editor_tab,
       config,
 //        sidebar_url: "/pinokio/sidebar/" + name,
       home: req.originalUrl,
@@ -3182,61 +3190,180 @@ class Server {
     }
   }
   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]
+    if (!this.kernel.peer || !this.kernel.peer.info) {
+      return
+    }
 
-      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
-        })
+    const ensureArray = (value) => {
+      if (!value) return []
+      return Array.isArray(value) ? value.filter(Boolean) : [value].filter(Boolean)
+    }
+
+    const normalizeHttpUrl = (value) => {
+      if (!value) return null
+      const str = String(value).trim()
+      if (!str) return null
+      if (/^https?:\/\//i.test(str)) {
+        return str.replace(/^https:/i, 'http:')
       }
-      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
+      return `http://${str}`
+    }
+
+    const normalizeHttpsUrl = (value) => {
+      if (!value) return null
+      const str = String(value).trim()
+      if (!str) return null
+      if (/^https?:\/\//i.test(str)) {
+        return str.replace(/^http:/i, 'https:')
+      }
+      return `https://${str}`
+    }
+
+    const seen = new Set()
+
+    const pushEntry = ({ host, name, ip, httpUrl, httpsUrls, description, icon, online = true }) => {
+      const normalizedHttp = normalizeHttpUrl(httpUrl)
+      const hostNameForAlias = host && host.name ? String(host.name).trim() : ''
+      const peerSuffix = hostNameForAlias ? `.${hostNameForAlias}.localhost` : null
+
+      const normalizedHttpsSet = new Set(
+        ensureArray(httpsUrls)
+          .map(normalizeHttpsUrl)
+          .filter(Boolean)
+      )
+
+      if (host && host.local && peerSuffix) {
+        for (const originalUrl of normalizedHttpsSet) {
+          try {
+            const parsed = new URL(originalUrl)
+            if (parsed.hostname.endsWith(peerSuffix)) {
+              const aliasHost = `${parsed.hostname.slice(0, -peerSuffix.length)}.localhost`
+              if (aliasHost && aliasHost !== parsed.hostname) {
+                let pathname = parsed.pathname || ''
+                if (pathname === '/' || pathname === '') {
+                  pathname = ''
+                }
+                const aliasUrl = `${parsed.protocol}//${aliasHost}${pathname}${parsed.search}${parsed.hash}`
+                normalizedHttpsSet.add(aliasUrl)
+              }
+            }
+          } catch (_) {
+            // continue
           }
-          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
+        }
+      }
+
+      const normalizedHttps = Array.from(normalizedHttpsSet)
+      const ipValue = typeof ip === 'string' ? ip : (normalizedHttp ? normalizedHttp.replace(/^https?:\/\//i, '') : null)
+      const selectedUrl = normalizedHttps[0] || normalizedHttp || null
+      const protocol = normalizedHttps.length > 0 ? 'https' : (normalizedHttp ? 'http' : undefined)
+      const hostKey = host && (host.ip || host.name) ? `${host.ip || host.name}` : 'unknown'
+      const uniquenessKey = `${hostKey}|${name}|${ipValue || ''}|${selectedUrl || ''}`
+      if (seen.has(uniquenessKey)) {
+        return
+      }
+      seen.add(uniquenessKey)
+
+      const entry = {
+        online,
+        host: { ...host },
+        name,
+        ip: ipValue,
+        url: selectedUrl,
+        protocol,
+        urls: {
+          http: normalizedHttp,
+          https: normalizedHttps
+        }
+      }
+      if (description) {
+        entry.description = description
+      }
+      if (icon) {
+        entry.icon = icon
+      }
+      info.push(entry)
+    }
+
+    for (const host of Object.keys(this.kernel.peer.info)) {
+      const hostInfo = this.kernel.peer.info[host]
+      if (!hostInfo) {
+        continue
+      }
+
+      const hostMeta = {
+        ip: host,
+        local: this.kernel.peer.host === host,
+        name: hostInfo.name,
+        platform: hostInfo.platform,
+        arch: hostInfo.arch
+      }
+
+      const rewrites = hostInfo.rewrite_mapping
+      if (rewrites && typeof rewrites === 'object') {
+        for (const key of Object.keys(rewrites)) {
+          const rewrite = rewrites[key]
+          if (!rewrite) {
+            continue
+          }
+          const externalIp = Array.isArray(rewrite.external_ip) ? rewrite.external_ip[0] : rewrite.external_ip
+          const httpsSources = [
+            ...ensureArray(rewrite.external_router),
+            ...ensureArray(rewrite.internal_router)
+          ]
+          pushEntry({
+            host: hostMeta,
+            name: `[Files] ${rewrite.name || key}`,
+            ip: externalIp || null,
+            httpUrl: externalIp,
+            httpsUrls: Array.from(new Set(httpsSources))
           })
         }
       }
 
-      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://", "")
+      const hostRouters = Array.isArray(hostInfo.router_info) ? hostInfo.router_info : []
+      for (const route of hostRouters) {
+        if (!route) {
+          continue
+        }
+        const externalIp = Array.isArray(route.external_ip) ? route.external_ip[0] : route.external_ip
+        const httpUrl = externalIp || null
+        const httpsCandidates = Array.from(new Set([
+          ...ensureArray(route.external_router),
+          ...ensureArray(route.internal_router)
+        ]))
+        if (httpsCandidates.length === 0 && !httpUrl) {
+          continue
+        }
+        pushEntry({
+          host: hostMeta,
+          name: route.title || route.name,
+          ip: externalIp || null,
+          httpUrl,
+          httpsUrls: httpsCandidates,
+          description: route.description,
+          icon: route.icon || route.https_icon || route.http_icon
+        })
+      }
+
+      const installedApps = Array.isArray(hostInfo.installed) ? hostInfo.installed : []
+      for (const app of installedApps) {
+        if (!app) {
+          continue
+        }
+        const httpHref = Array.isArray(app.http_href) ? app.http_href[0] : app.http_href
+        const httpsCandidates = Array.from(new Set([
+          ...ensureArray(app.app_href),
+          ...ensureArray(app.https_href)
+        ]))
+        pushEntry({
+          host: hostMeta,
+          name: app.title || app.name || app.folder,
+          ip: httpHref ? httpHref.replace(/^https?:\/\//i, '') : null,
+          httpUrl: httpHref || null,
+          httpsUrls: httpsCandidates,
+          description: app.description,
+          icon: app.https_icon || app.http_icon || app.icon
         })
       }
     }
@@ -3267,14 +3394,14 @@ class Server {
       }
       terminal = {
         icon: "fa-solid fa-terminal",
-        title: "Terminal",
+        title: "User Terminal",
         subtitle: "Open the terminal in the browser",
         menu: terminals
       }
     } else {
       terminal = {
         icon: "fa-solid fa-terminal",
-        title: "Terminal",
+        title: "User Terminal",
         subtitle: "Work with the terminal directly in the browser",
         menu: [this.renderShell(filepath, 0, 0, {
           icon: "fa-solid fa-terminal",
@@ -3730,6 +3857,11 @@ class Server {
       };
       next();
     });
+    registerFileRoutes(this.app, {
+      kernel: this.kernel,
+      getTheme: () => this.theme,
+      exists: (target) => this.exists(target),
+    });
     /*
     this.app.get("/asset/*", ex((req, res) => {
       let pathComponents = req.params[0].split("/")
@@ -4527,7 +4659,6 @@ class Server {
       }
     }))
     this.app.post("/push", ex(async (req, res) => {
-      console.log("Push", req.body)
       try {
         const payload = { ...(req.body || {}) }
         const resolveAssetPath = (raw) => {
@@ -6222,6 +6353,7 @@ class Server {
           menu: exec_menus
         },
       ]
+
       let spec = ""
       try {
         spec = await fs.promises.readFile(path.resolve(filepath, "SPEC.md"), "utf8")
@@ -6610,6 +6742,7 @@ class Server {
         if (preferHttps) {
           httpsHosts = resolveHttpsHosts(item)
         }
+        console.log("httpsHosts", httpsHosts)
         const httpsUrls = httpsHosts.map((host) => {
           if (!host) {
             return null
@@ -6620,6 +6753,7 @@ class Server {
           }
           return `https://${trimmed}`
         }).filter(Boolean)
+        console.log("httpsUrls", httpsUrls)
 
         const preferredHttpsUrl = preferFriendlyHost(httpsHosts)
         const displayHttpsUrl = preferredHttpsUrl
@@ -6648,7 +6782,7 @@ class Server {
         }
       })
 
-//      this.add_extra_urls(info)
+      this.add_extra_urls(info)
       res.json({
         info
       })