pinokiod 3.230.0 → 3.232.0

package/kernel/bin/cuda.js

@@ -3,100 +3,107 @@ const fs = require('fs')
 const path = require('path')
 class Cuda {
   async install(req, ondata) {
-    if (this.kernel.platform === "win32") {
-      await this.kernel.bin.exec({
-        message: [
-          "conda clean -y --all",
-          "conda install -y cudnn libzlib-wapi -c conda-forge",
-        ]
-      }, ondata)
-      await this.kernel.bin.exec({
-        message: [
-          "conda clean -y --all",
-          "conda install -y nvidia/label/cuda-12.8.1::cuda"
-        ]
-      }, ondata)
-      const folder = this.kernel.bin.path("miniconda/etc/conda/activate.d")
-      let deactivate_list = [
-        "~cuda-nvcc_activate.bat",
-        "vs2019_compiler_vars.bat",
-        "vs2022_compiler_vars.bat",
-      ]
-      for(let item of deactivate_list) {
-        const old_name = path.resolve(folder, item)
-        const new_name = path.resolve(folder, item + ".disabled")
-        console.log("rename", { old_name, new_name })
-        await fs.promises.rename(old_name, new_name)
-      }
-    } else {
-      await this.kernel.bin.exec({
-        message: [
-          "conda clean -y --all",
-          "conda install -y cudnn -c conda-forge",
-        ]
-      }, ondata)
-      await this.kernel.bin.exec({
-        message: [
-          "conda clean -y --all",
-          "conda install -y nvidia/label/cuda-12.8.1::cuda"
+    if (this.kernel.gpu === "nvidia") {
+      if (this.kernel.platform === "win32") {
+        await this.kernel.bin.exec({
+          message: [
+            "conda clean -y --all",
+            "conda install -y cudnn libzlib-wapi -c conda-forge",
+          ]
+        }, ondata)
+        await this.kernel.bin.exec({
+          message: [
+            "conda clean -y --all",
+            "conda install -y nvidia/label/cuda-12.8.1::cuda"
+          ]
+        }, ondata)
+        const folder = this.kernel.bin.path("miniconda/etc/conda/activate.d")
+        let deactivate_list = [
+          "~cuda-nvcc_activate.bat",
+          "vs2019_compiler_vars.bat",
+          "vs2022_compiler_vars.bat",
         ]
-      }, ondata)
-      if (this.kernel.platform === "linux") {
+        for(let item of deactivate_list) {
+          const old_name = path.resolve(folder, item)
+          const new_name = path.resolve(folder, item + ".disabled")
+          console.log("rename", { old_name, new_name })
+          await fs.promises.rename(old_name, new_name)
+        }
+      } else {
         await this.kernel.bin.exec({
           message: [
-            "conda install -y -c conda-forge nccl"
+            "conda clean -y --all",
+            "conda install -y cudnn -c conda-forge",
           ]
         }, ondata)
+        await this.kernel.bin.exec({
+          message: [
+            "conda clean -y --all",
+            "conda install -y nvidia/label/cuda-12.8.1::cuda"
+          ]
+        }, ondata)
+        if (this.kernel.platform === "linux") {
+          await this.kernel.bin.exec({
+            message: [
+              "conda install -y -c conda-forge nccl"
+            ]
+          }, ondata)
+        }
       }
     }
   }
   async installed() {
-    if (this.kernel.platform === 'win32') {
-      if (this.kernel.bin.installed.conda.has("cudnn") && this.kernel.bin.installed.conda.has("cuda") && this.kernel.bin.installed.conda.has("libzlib-wapi")) {
-        let version = this.kernel.bin.installed.conda_versions.cuda
-        if (version) {
-          let coerced = semver.coerce(version)
-          console.log("cuda version", coerced)
-          if (semver.satisfies(coerced, ">=12.8.1")) {
-            console.log("cuda satisfied")
-            let deactivate_list = [
-              "~cuda-nvcc_activate.bat",
-              "vs2019_compiler_vars.bat",
-              "vs2022_compiler_vars.bat",
-            ]
-            const folder = this.kernel.bin.path("miniconda/etc/conda/activate.d")
-            let at_least_one_exists = false
-            for(let item of deactivate_list) {
-              let exists = await this.kernel.exists("bin/miniconda/etc/conda/activate.d/" + item)
-              if (exists) {
-                // break if at least one exists
-                at_least_one_exists = true
-                break
+    if (this.kernel.gpu === "nvidia") {
+      if (this.kernel.platform === 'win32') {
+        if (this.kernel.bin.installed.conda.has("cudnn") && this.kernel.bin.installed.conda.has("cuda") && this.kernel.bin.installed.conda.has("libzlib-wapi")) {
+          let version = this.kernel.bin.installed.conda_versions.cuda
+          if (version) {
+            let coerced = semver.coerce(version)
+            console.log("cuda version", coerced)
+            if (semver.satisfies(coerced, ">=12.8.1")) {
+              console.log("cuda satisfied")
+              let deactivate_list = [
+                "~cuda-nvcc_activate.bat",
+                "vs2019_compiler_vars.bat",
+                "vs2022_compiler_vars.bat",
+              ]
+              const folder = this.kernel.bin.path("miniconda/etc/conda/activate.d")
+              let at_least_one_exists = false
+              for(let item of deactivate_list) {
+                let exists = await this.kernel.exists("bin/miniconda/etc/conda/activate.d/" + item)
+                if (exists) {
+                  // break if at least one exists
+                  at_least_one_exists = true
+                  break
+                }
+              }
+              console.log("nvcc_activate exists?", at_least_one_exists)
+              if (at_least_one_exists) {
+                return false
+              } else {
+                return true
               }
             }
-            console.log("nvcc_activate exists?", at_least_one_exists)
-            if (at_least_one_exists) {
-              return false
-            } else {
+          }
+        }
+      } else {
+        if (this.kernel.bin.installed.conda.has("cudnn") && this.kernel.bin.installed.conda.has("cuda")) {
+          let version = this.kernel.bin.installed.conda_versions.cuda
+          if (version) {
+            let coerced = semver.coerce(version)
+            console.log("cuda version", coerced)
+            if (semver.satisfies(coerced, ">=12.8.1")) {
+              console.log("satisfied")
               return true
             }
           }
         }
       }
+      return false
     } else {
-      if (this.kernel.bin.installed.conda.has("cudnn") && this.kernel.bin.installed.conda.has("cuda")) {
-        let version = this.kernel.bin.installed.conda_versions.cuda
-        if (version) {
-          let coerced = semver.coerce(version)
-          console.log("cuda version", coerced)
-          if (semver.satisfies(coerced, ">=12.8.1")) {
-            console.log("satisfied")
-            return true
-          }
-        }
-      }
+      // just return true for all other gpus so they can be avoided
+      return true
     }
-    return false
   }
   env() {
     return {

package/kernel/bin/setup.js

@@ -157,12 +157,14 @@ module.exports = {
       { name: "cli", },
       { name: "uv", },
       { name: "py", },
+      { name: "huggingface" },
       { name: "browserless" },
     ])
     let conda_requirements = [
       zip_cmd,
       "uv",
       "node",
+      "huggingface",
       "git",
     ]
     return {

package/kernel/prototype.js

@@ -109,6 +109,19 @@ class Proto {
       let mod = await this.kernel.require(mod_path)
       let response = await mod(payload, ondata, this.kernel)
 
+      if (projectType === 'dns') {
+        try {
+          await this.kernel.dns({ path: payload.cwd })
+        } catch (dnsError) {
+          console.log('[proto] dns update failed', dnsError)
+        }
+        try {
+          await this.kernel.refresh(true)
+        } catch (refreshError) {
+          console.log('[proto] refresh failed after dns create', refreshError)
+        }
+      }
+
 //      // copy readme
 //      let readme_path = this.kernel.path("prototype/PINOKIO.md")
 //      await fs.promises.cp(readme_path, path.resolve(cwd, name, "PINOKIO.md"))

package/kernel/router/index.js

@@ -38,6 +38,7 @@ class Router {
     this.local_network_mapping = {}
     this.custom_routers = {}
     this.rewrite_mapping = {}
+    this.stream_close_delay = '10m'
   }
   async init() {
     // if ~/pinokio/network doesn't exist, clone
@@ -258,6 +259,14 @@ class Router {
       }
     }
     this.mapping = this._mapping
+
+    // set self origins => used for detecting all IPs resembling pinokiod itself
+    const basePort = Number(this.kernel.server_port || this.default_port)
+    const mappedPort = this.port_mapping && basePort ? Number(this.port_mapping[String(basePort)]) : null
+    const lanHost = (this.kernel.peer && this.kernel.peer.host) ? String(this.kernel.peer.host).trim() : ''
+    const hosts = ['127.0.0.1', 'localhost', lanHost].filter(Boolean)
+    const ports = [basePort, mappedPort].filter((value) => Number.isFinite(value))
+    this.kernel.selfOrigins = hosts.flatMap((host) => ports.map((port) => `${host}:${port}`))
   }
 
   fallback() {
@@ -299,8 +308,40 @@ class Router {
     this.mapping = this._mapping
   }
 
+  ensureStreamCloseDelay(target) {
+    const delay = this.stream_close_delay
+    if (!delay || !target) {
+      return
+    }
+    const seen = new WeakSet()
+    const visit = (node) => {
+      if (!node || (typeof node === 'object' && seen.has(node))) {
+        return
+      }
+      if (typeof node === 'object') {
+        seen.add(node)
+      }
+      if (Array.isArray(node)) {
+        for (const item of node) {
+          visit(item)
+        }
+        return
+      }
+      if (typeof node === 'object') {
+        if (node.handler === 'reverse_proxy' && typeof node.stream_close_delay === 'undefined') {
+          node.stream_close_delay = delay
+        }
+        for (const key of Object.keys(node)) {
+          visit(node[key])
+        }
+      }
+    }
+    visit(target)
+  }
+
   // update caddy config
   async update() {
+    this.ensureStreamCloseDelay(this.config)
     if (JSON.stringify(this.config) === JSON.stringify(this.old_config)) {
 //      console.log("######### config hasn't updated")
     } else {

package/package.json

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

package/server/index.js

@@ -441,6 +441,7 @@ class Server {
         //browser_url = "/pinokio/browser/" + x.name
         browser_url = "/p/" + x.name
       }
+      let view_url = "/v/" + x.name
       let dev_url = browser_url + "/dev"
       let review_url = browser_url + "/review"
       let files_url = "/asset/api/" + x.name
@@ -469,6 +470,7 @@ class Server {
         url: browser_url,
         path: uri,
         dev_url,
+        view_url,
         review_url,
         files_url,
       }
@@ -703,12 +705,11 @@ class Server {
 //    return current_urls
   }
 
-  async chrome(req, res, type) {
+  async chrome(req, res, type, options) {
 
     let d = Date.now()
     let { requirements, install_required, requirements_pending, error } = await this.kernel.bin.check({
-      //bin: this.kernel.bin.preset("dev"),
-      bin: this.kernel.bin.preset("ai"),
+      bin: this.kernel.bin.preset("dev"),
     })
     if (!requirements_pending && install_required) {
       res.redirect(`/setup/dev?callback=${req.originalUrl}`)
@@ -849,7 +850,20 @@ class Server {
       dev_link = "/d/" + posix_path
     }
 
-    let run_tab = "/p/" + name
+    let autoselect
+    let run_tab
+    if (type === "run") {
+      if (options && options.no_autoselect) {
+        run_tab = "/v/" + name
+        autoselect = false
+      } else {
+        run_tab = "/p/" + name
+        autoselect = true
+      }
+    } else {
+      run_tab = "/p/" + name
+      autoselect = false
+    }
     let dev_tab = "/p/" + name + "/dev"
     let review_tab = "/p/" + name + "/review"
     let files_tab = "/p/" + name + "/files"
@@ -888,6 +902,7 @@ class Server {
       port: this.port,
 //      mem,
       type,
+      autoselect,
       platform,
       running:this.kernel.api.running,
       memory: this.kernel.memory,
@@ -1676,12 +1691,29 @@ class Server {
           template = "editor"
         }
 
+        let requires_bundle = null
+        if (resolved && resolved.requires && !Array.isArray(resolved.requires)) {
+          const bundle = resolved.requires.bundle
+          if (typeof bundle === "string" && typeof Setup[bundle] === "function") {
+            requires_bundle = bundle
+          }
+        }
+
+        const preset = requires_bundle ? this.kernel.bin.preset(requires_bundle) : this.kernel.bin.preset("dev")
         let { requirements, install_required, requirements_pending, error } = await this.kernel.bin.check({
-          //bin: this.kernel.bin.preset("ai"),
-          bin: this.kernel.bin.preset("dev"),
+          bin: preset,
           script: resolved
         })
 
+        if (requires_bundle) {
+          console.log({ requires_bundle, requirements_pending, install_required,  })
+        }
+
+        if (requires_bundle && !requirements_pending && install_required) {
+          res.redirect(`/setup/${requires_bundle}?callback=${req.originalUrl}`)
+          return
+        }
+
         //let requirements = this.kernel.bin.requirements(resolved)
         //let requirements_pending = !this.kernel.bin.installed_initialized
         //let install_required = true
@@ -3367,7 +3399,7 @@ class Server {
           ]
           pushEntry({
             host: hostMeta,
-            name: `[Files] ${rewrite.name || key}`,
+            name: `[Website] ${rewrite.name || key}`,
             ip: externalIp || null,
             httpUrl: externalIp,
             httpsUrls: Array.from(new Set(httpsSources))
@@ -3400,26 +3432,26 @@ class Server {
         })
       }
 
-      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
-        })
-      }
+//      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
+//        })
+//      }
     }
   }
   async terminals(filepath) {
@@ -3727,6 +3759,7 @@ class Server {
 
 
     await this.kernel.init({ port: this.port})
+    this.kernel.server_port = this.port
     this.kernel.peer.start(this.kernel)
 
 
@@ -5493,6 +5526,18 @@ class Server {
         requirements_pending,
       })
     }))
+    this.app.get("/net/:name/diff", ex(async (req, res) => {
+      try {
+        let processes = this.kernel.peer.info[this.kernel.peer.host].router_info
+        let last_proc = JSON.stringify(this.kernel.last_processes)
+        let current_proc = JSON.stringify(processes)
+        this.kernel.last_processes = processes
+        res.json({ diff: last_proc !== current_proc })
+      } catch (e) {
+        console.log("ERROR", e)
+        res.json({ diff: true })
+      }
+    }))
     this.app.get("/net/:name", ex(async (req, res) => {
       let protocol = req.get('X-Forwarded-Proto') || "http"
       let { requirements, install_required, requirements_pending, error } = await this.kernel.bin.check({
@@ -5546,6 +5591,7 @@ class Server {
       const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
       let peer_qr = null
       try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
+      const allow_dns_creation = req.params.name === this.kernel.peer.name
       res.render("net", {
         static_routes,
         selected_name: req.params.name,
@@ -5566,6 +5612,8 @@ class Server {
         current_host: this.kernel.peer.host,
         peer_url,
         peer_qr,
+        cwd: this.kernel.path("api"),
+        allow_dns_creation,
       })
     }))
     this.app.get("/network", ex(async (req, res) => {
@@ -7102,7 +7150,13 @@ class Server {
         return hosts[0]
       }
 
-      const info = this.kernel.processes.info.map((item) => {
+      const processes = Array.isArray(this.kernel.processes.info) ? this.kernel.processes.info : []
+      const serverPid = Number(process.pid)
+      const filteredProcesses = Number.isFinite(serverPid)
+        ? processes.filter((item) => Number(item && item.pid) !== serverPid)
+        : processes.slice()
+
+      let info = filteredProcesses.map((item) => {
         const httpUrl = item.ip ? `http://${item.ip}` : null
         let httpsHosts = []
         if (preferHttps) {
@@ -7148,6 +7202,12 @@ class Server {
 
       this.add_extra_urls(info)
 
+      if (Array.isArray(this.kernel.selfOrigins) && this.kernel.selfOrigins.length > 0) {
+        info = info.filter((entry) => {
+          return !this.kernel.selfOrigins.includes(entry.ip)
+        })
+      }
+
       const toArray = (value) => {
         if (!value) return []
         return Array.isArray(value) ? value.filter(Boolean) : [value].filter(Boolean)
@@ -7428,7 +7488,9 @@ class Server {
     this.app.get("/pinokio/browser/:name", ex(async (req, res) => {
       await this.chrome(req, res, "run")
     }))
-
+    this.app.get("/v/:name", ex(async (req, res) => {
+      await this.chrome(req, res, "run", { no_autoselect: true })
+    }))
 
     this.app.get("/p/:name/review", ex(async (req, res) => {
       let gitRemote = null

package/server/public/container-tab-link.js

@@ -0,0 +1,115 @@
+(function () {
+  const api = window.PinokioTabLinkPopover
+  if (!api) {
+    return
+  }
+  const { renderTabLinkPopover, hideTabLinkPopover, isLocalHostLike } = api
+
+  const getPopoverEl = () => document.getElementById('tab-link-popover')
+
+  const ensureHttpUrl = (value) => {
+    if (typeof value !== 'string') {
+      return ''
+    }
+    let trimmed = value.trim()
+    if (!trimmed) {
+      return ''
+    }
+    if (!/^https?:\/\//i.test(trimmed)) {
+      if (/^[a-z]+:\/\//i.test(trimmed)) {
+        return ''
+      }
+      trimmed = `http://${trimmed}`
+    }
+    try {
+      const parsed = new URL(trimmed)
+      if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return ''
+      }
+      return parsed.toString()
+    } catch (_) {
+      return ''
+    }
+  }
+
+  const isLocalUrl = (value) => {
+    if (!value) {
+      return false
+    }
+    try {
+      const parsed = new URL(value)
+      return isLocalHostLike(parsed.hostname)
+    } catch (_) {
+      return false
+    }
+  }
+
+  const resolveCurrentUrl = (input) => {
+    if (input && typeof input.value === 'string' && input.value.trim().length > 0) {
+      const normalized = ensureHttpUrl(input.value)
+      if (normalized) {
+        return normalized
+      }
+    }
+    const fallback = input?.getAttribute('value')
+    return ensureHttpUrl(fallback || '')
+  }
+
+  const showPopoverForAnchor = (anchor, urlInput) => {
+    if (!anchor) {
+      return
+    }
+    const currentUrl = resolveCurrentUrl(urlInput)
+    if (!currentUrl || !isLocalUrl(currentUrl)) {
+      hideTabLinkPopover({ immediate: true })
+      return
+    }
+    renderTabLinkPopover(anchor, {
+      hrefOverride: currentUrl,
+      requireAlternate: false,
+      restrictToBase: true,
+      forceCanonicalQr: true,
+      allowQrPortMismatch: true,
+      skipPeerFallback: true
+    })
+  }
+
+  const handleMouseLeave = (anchor, event) => {
+    const related = event.relatedTarget
+    const popover = getPopoverEl()
+    if (related && (anchor.contains(related) || (popover && popover.contains(related)))) {
+      return
+    }
+    hideTabLinkPopover()
+  }
+
+  const init = () => {
+    const container = document.querySelector('.url-input-container')
+    const urlInput = container ? container.querySelector('input[type="url"]') : null
+    const mobileButton = document.getElementById('mobile-link-button')
+
+    if (container) {
+      container.addEventListener('mouseover', () => showPopoverForAnchor(container, urlInput))
+      container.addEventListener('mouseout', (event) => handleMouseLeave(container, event))
+      const inputFocus = () => showPopoverForAnchor(container, urlInput)
+      const inputBlur = (event) => handleMouseLeave(container, event)
+      if (urlInput) {
+        urlInput.addEventListener('focus', inputFocus)
+        urlInput.addEventListener('blur', inputBlur)
+      }
+    }
+
+    if (mobileButton) {
+      mobileButton.addEventListener('mouseover', () => showPopoverForAnchor(mobileButton, urlInput))
+      mobileButton.addEventListener('mouseout', (event) => handleMouseLeave(mobileButton, event))
+      mobileButton.addEventListener('focus', () => showPopoverForAnchor(mobileButton, urlInput))
+      mobileButton.addEventListener('blur', (event) => handleMouseLeave(mobileButton, event))
+    }
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init)
+  } else {
+    init()
+  }
+})()

package/server/public/style.css

@@ -2816,3 +2816,7 @@ header.navheader.minimized .home .icon {
 header.navheader.transitioning {
   pointer-events: none;
 }
+
+.shutdown i.fa-stop:hover {
+  color: crimson;
+}