pinokiod 3.86.0 → 3.87.0

package/kernel/peer.js

@@ -40,20 +40,26 @@ class PeerDiscovery {
     }
   }
   async check(kernel) {
-    let env = await Environment.get(kernel.homedir, kernel)
-    let peer_active = true
-    //let peer_active = false
-    if (env && env.PINOKIO_NETWORK_ACTIVE && (env.PINOKIO_NETWORK_ACTIVE==="1" || env.PINOKIO_NETWORK_ACTIVE.toLowerCase()==="true")) {
-    //if (env && env.PINOKIO_NETWORK_ACTIVE && (env.PINOKIO_NETWORK_ACTIVE==="0" || env.PINOKIO_NETWORK_ACTIVE.toLowerCase()==="false")) {
-      peer_active = true
-    }
-    //let https_active = true
-    let https_active = false
-    if (env && env.PINOKIO_HTTPS_ACTIVE && (env.PINOKIO_HTTPS_ACTIVE==="1" || env.PINOKIO_HTTPS_ACTIVE.toLowerCase()==="true")) {
-    //if (env && env.PINOKIO_HTTPS_ACTIVE && (env.PINOKIO_HTTPS_ACTIVE==="0" || env.PINOKIO_HTTPS_ACTIVE.toLowerCase()==="false")) {
-      https_active = true
-      //https_active = false 
+    const env = await Environment.get(kernel.homedir, kernel)
+    const resolveFlag = (key, fallback) => {
+      const fromEnvFile = env && typeof env[key] !== 'undefined' ? String(env[key]) : undefined
+      const fromProcess = typeof process.env[key] !== 'undefined' ? String(process.env[key]) : undefined
+      const value = typeof fromProcess !== 'undefined' ? fromProcess : fromEnvFile
+      if (typeof value === 'undefined' || value === null) {
+        return fallback
+      }
+      const normalized = value.trim().toLowerCase()
+      if (normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on') {
+        return true
+      }
+      if (normalized === '0' || normalized === 'false' || normalized === 'no' || normalized === 'off') {
+        return false
+      }
+      return fallback
     }
+
+    const peer_active = resolveFlag('PINOKIO_NETWORK_ACTIVE', true)
+    const https_active = resolveFlag('PINOKIO_HTTPS_ACTIVE', false)
 //    console.log("kernel.refresh", { active, notify_peers })
 
     //this.name = os.userInfo().username
@@ -276,8 +282,6 @@ class PeerDiscovery {
 //          let ip = 
 //          if (router[proc.ip]) {
 //          }proc.
-
-
           let info = {
             external_router: router[external_ip] || [],
             internal_router,
@@ -286,6 +290,29 @@ class PeerDiscovery {
             internal_port: parseInt(internal_port),
             ...proc,
           }
+          const usingCustomDomain = this.kernel.router_kind === 'custom-domain'
+          if (usingCustomDomain) {
+            if ((!info.external_router || info.external_router.length === 0)) {
+              const fallbackKeys = new Set([
+                proc.ip,
+                `${internal_host}:${proc.port}`,
+                `127.0.0.1:${proc.port}`,
+                `0.0.0.0:${proc.port}`,
+                `localhost:${proc.port}`
+              ])
+              for (const key of fallbackKeys) {
+                if (key && router[key] && router[key].length > 0) {
+                  info.external_router = router[key]
+                  break
+                }
+              }
+            }
+            if (info.external_router && info.external_router.length > 0) {
+              info.external_router = Array.from(new Set(info.external_router))
+            } else if (internal_router.length > 0) {
+              info.external_router = Array.from(new Set(internal_router))
+            }
+          }
           let cached = this.router_info_cache[pid]
           let cached_str = JSON.stringify(cached)
           let info_str = JSON.stringify(info)

package/kernel/router/index.js

@@ -100,11 +100,18 @@ class Router {
       }
     }
 
-    let env = await Environment.get(this.kernel.homedir, this.kernel)
-    this.active = false
-    if (env && env.PINOKIO_HTTPS_ACTIVE && (env.PINOKIO_HTTPS_ACTIVE==="1" || env.PINOKIO_HTTPS_ACTIVE.toLowerCase()==="true")) {
-      this.active = true
-    }
+    const env = await Environment.get(this.kernel.homedir, this.kernel)
+    const httpsFlag = (() => {
+      const fromEnvFile = env && typeof env.PINOKIO_HTTPS_ACTIVE !== 'undefined' ? String(env.PINOKIO_HTTPS_ACTIVE) : undefined
+      const fromProcess = typeof process.env.PINOKIO_HTTPS_ACTIVE !== 'undefined' ? String(process.env.PINOKIO_HTTPS_ACTIVE) : undefined
+      const value = typeof fromProcess !== 'undefined' ? fromProcess : fromEnvFile
+      if (typeof value === 'undefined') {
+        return false
+      }
+      const normalized = value.trim().toLowerCase()
+      return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on'
+    })()
+    this.active = httpsFlag
 
 
   }
@@ -217,16 +224,16 @@ class Router {
   }
 
   async static() {
-//    this.localhost_static_router.handle()
-//    for(let host in this.kernel.peer.info) {
-//      let info = this.kernel.peer.info[host]
-//      if (info.rewrite_mapping) {
-//        for(let name in info.rewrite_mapping) {
-//          this.peer_static_router.handle(info.rewrite_mapping[name])
-//        }
-//      }
-//    }
-//    this.mapping = this._mapping
+    this.localhost_static_router.handle()
+    for(let host in this.kernel.peer.info) {
+      let info = this.kernel.peer.info[host]
+      if (info.rewrite_mapping) {
+        for(let name in info.rewrite_mapping) {
+          this.peer_static_router.handle(info.rewrite_mapping[name])
+        }
+      }
+    }
+    this.mapping = this._mapping
   }
 
   // set local config
@@ -300,6 +307,7 @@ class Router {
 //      console.log("######### caddy config has updated. refresh")
 //      console.log("Old", JSON.stringify(this.old_config, null, 2))
 //      console.log("New", JSON.stringify(this.config, null, 2))
+      console.log('[router] detected config changes, posting update to caddy (default router)')
       try {
         console.log("Try loading caddy config") 
         let response = await axios.post('http://127.0.0.1:2019/load', this.config, {

package/kernel/router/localhost_static_router.js

@@ -12,7 +12,6 @@ class LocalhostStaticRouter extends Processor {
     this.rewriter = new Rewriter(router)
   }
   handle () {
-    console.log("LOCALHOST STATIC ROUTER")
     let configs = []
     for(let api_name in this.router.kernel.pinokio_configs) {
       let config = this.router.kernel.pinokio_configs[api_name]
@@ -42,13 +41,11 @@ class LocalhostStaticRouter extends Processor {
             let local_dial = `${this.router.default_host}:${this.router.default_port}`
             let peer_dial = `${this.router.kernel.peer.host}:${this.router.default_port}`
             let rewrite = `/asset/api/${api_name}`
-            console.log("LOCALHOST REWRITE HANDLE", { rewrite, localhost_match, local_dial })
             this.rewriter.handle({
               route: rewrite,
               match: [localhost_match],
               dial: local_dial,
             })
-            console.log("LOCALHOST REWRITE HANDLE", { rewrite, peer_match, peer_dial })
             this.rewriter.handle({
               route: rewrite,
               match: [peer_match],

package/kernel/router/pinokio_domain_router.js

@@ -0,0 +1,333 @@
+const axios = require('axios')
+const Environment = require('../environment')
+const Common = require('./common')
+
+class PinokioDomainRouter {
+  constructor(kernel) {
+    this.kernel = kernel
+    this.common = new Common(this)
+    this.domainSuffix = ''
+    this.custom_routers = {}
+    this.resetState()
+    this.old_config = null
+    this.info = {}
+    this.active = false
+  }
+
+  resetState() {
+    this._mapping = {}
+    this.mapping = {}
+    this.rewrite_mapping = {}
+    this.port_mapping = {}
+    this.local_network_mapping = {}
+    this.port_cache = {}
+  }
+
+  async init() {
+    this.resetState()
+    await this.loadDomainSuffix()
+    this.setupBaseConfig()
+  }
+
+  async loadDomainSuffix() {
+    const envDomain = (process.env.PINOKIO_DOMAIN || '').trim()
+    if (envDomain) {
+      this.domainSuffix = envDomain.toLowerCase()
+    } else {
+      const env = await Environment.get(this.kernel.homedir, this.kernel)
+      this.domainSuffix = (env.PINOKIO_DOMAIN || '').trim().toLowerCase()
+    }
+    this.active = this.domainSuffix.length > 0
+  }
+
+  setupBaseConfig() {
+    this.config = {
+      apps: {
+        http: {
+          servers: {
+            main: {
+              listen: [':8080'],
+              automatic_https: {
+                disable: true
+              },
+              routes: [
+                {
+                  match: [{ method: ['OPTIONS'] }],
+                  handle: [
+                    {
+                      handler: 'headers',
+                      response: {
+                        set: {
+                          'Access-Control-Allow-Origin': ['*'],
+                          'Access-Control-Allow-Methods': ['GET, POST, OPTIONS, PUT, DELETE'],
+                          'Access-Control-Allow-Headers': ['*'],
+                          Vary: ['Origin']
+                        }
+                      }
+                    },
+                    {
+                      handler: 'static_response',
+                      status_code: 204
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+        }
+      },
+      logging: {
+        logs: {
+          default: {
+            writer: {
+              output: 'file',
+              filename: this.kernel.path('logs/caddy.log'),
+              roll: true,
+              roll_size_mb: 1,
+              roll_keep: 1,
+              roll_keep_days: 1,
+              roll_gzip: false,
+              roll_local_time: true
+            },
+            level: 'INFO'
+          }
+        }
+      }
+    }
+  }
+
+  normalizeLabel(value) {
+    if (!value || typeof value !== 'string') {
+      return ''
+    }
+    return value
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '')
+  }
+
+  domainFor(apiName) {
+    if (!this.active) {
+      return null
+    }
+    const label = this.normalizeLabel(apiName)
+    if (!label) {
+      return null
+    }
+    return `${label}-${this.domainSuffix}`
+  }
+
+  extractPrimaryUrl(local) {
+    if (!local || typeof local !== 'object') {
+      return null
+    }
+    const preferredKeys = ['url', 'public_url', 'local_url']
+    for (const key of preferredKeys) {
+      const val = local[key]
+      if (typeof val === 'string' && this.isHttp(val)) {
+        return val
+      }
+    }
+
+    const queue = [local]
+    const visited = new Set()
+    while (queue.length > 0) {
+      const current = queue.shift()
+      if (!current || typeof current !== 'object') {
+        continue
+      }
+      if (visited.has(current)) {
+        continue
+      }
+      visited.add(current)
+      const iterable = Array.isArray(current) ? current : Object.values(current)
+      for (const val of iterable) {
+        if (typeof val === 'string' && this.isHttp(val)) {
+          return val
+        }
+        if (val && typeof val === 'object') {
+          queue.push(val)
+        }
+      }
+    }
+    return null
+  }
+
+  isHttp(value) {
+    return /^https?:\/\//i.test(value)
+  }
+
+  firstUrl(entries) {
+    if (!Array.isArray(entries)) {
+      return null
+    }
+    for (const entry of entries) {
+      const local = entry && entry.local
+      const url = this.extractPrimaryUrl(local)
+      if (url) {
+        return url
+      }
+    }
+    return null
+  }
+
+  attachRoute({ domain, url }) {
+    if (!domain || !url) {
+      return
+    }
+    let parsed
+    try {
+      parsed = new URL(url)
+    } catch (error) {
+      return
+    }
+
+    const isHttps = /^https:/i.test(parsed.protocol || '')
+    const port = parsed.port || (isHttps ? '443' : '80')
+    let hostname = parsed.hostname || ''
+    if (!hostname) {
+      return
+    }
+
+    if (hostname.includes(':') && !hostname.startsWith('[')) {
+      hostname = `[${hostname}]`
+    }
+
+    const dial = `${hostname}:${port}`
+    const match = domain.toLowerCase()
+    this.common.handle({
+      match,
+      dial,
+      host: this.kernel.peer.host
+    })
+  }
+
+  async local() {
+    if (!this.active) {
+      this.mapping = {}
+      this.info = {}
+      return
+    }
+
+    this.setupBaseConfig()
+
+    const baseDomain = this.domainSuffix ? this.domainSuffix.toLowerCase() : ''
+    if (baseDomain) {
+      this.common.handle({
+        match: baseDomain,
+        dial: '127.0.0.1:42000',
+        host: this.kernel.peer.host
+      })
+    }
+
+    const scriptsByApi = this.kernel.info && typeof this.kernel.info.scriptsByApi === 'function'
+      ? this.kernel.info.scriptsByApi()
+      : {}
+
+    const usedDomains = new Set()
+    for (const [apiName, entries] of Object.entries(scriptsByApi)) {
+      const domain = this.domainFor(apiName)
+      if (!domain || usedDomains.has(domain)) {
+        continue
+      }
+      const url = this.firstUrl(entries)
+      if (!url) {
+        continue
+      }
+      this.attachRoute({ domain, url })
+      usedDomains.add(domain)
+    }
+
+    this.mapping = this._mapping
+    this.info = this._info()
+  }
+
+  async remote() {
+    // no-op for custom domain router
+  }
+
+  async static() {
+    // no-op for custom domain router
+  }
+
+  async custom_domain() {
+    // no-op for custom domain router
+  }
+
+  fallback() {
+    // no default fallback required for custom domain router
+  }
+
+  add({ host, dial, match }) {
+    if (!this._mapping[host]) {
+      this._mapping[host] = {}
+    }
+    if (!this._mapping[host][dial]) {
+      this._mapping[host][dial] = new Set()
+    }
+    if (Array.isArray(match)) {
+      for (const m of match) {
+        this._mapping[host][dial].add(m)
+      }
+    } else {
+      this._mapping[host][dial].add(match)
+    }
+  }
+
+  _info() {
+    const mapping = {}
+    for (const host in this.mapping) {
+      const internal = this.mapping[host]
+      if (!mapping[host]) {
+        mapping[host] = {}
+      }
+      for (const url in internal) {
+        mapping[host][url] = Array.from(internal[url])
+      }
+    }
+    return mapping
+  }
+
+  published() {
+    const pub = {}
+    if (this.info) {
+      const routes = this.info[this.kernel.peer.host]
+      if (routes) {
+        for (const dial in routes) {
+          pub[dial] = routes[dial]
+        }
+      }
+    }
+    return pub
+  }
+
+  async update() {
+    if (JSON.stringify(this.config) === JSON.stringify(this.old_config)) {
+      return
+    }
+    console.log('[router] detected config changes, posting update to caddy (custom domain router)')
+    try {
+      console.log('Try loading caddy config [custom domain]')
+      await axios.post('http://127.0.0.1:2019/load', this.config, {
+        headers: { 'Content-Type': 'application/json' }
+      })
+      this.old_config = this.config
+    } catch (error) {
+      console.log('Caddy Request Failed [custom domain]', error)
+    }
+  }
+
+  async check() {
+    try {
+      const res = await axios.get('http://localhost:2019/config/', {
+        timeout: 2000
+      })
+      return res.data
+    } catch (error) {
+      return null
+    }
+  }
+}
+
+module.exports = PinokioDomainRouter

package/kernel/shells.js

@@ -50,6 +50,23 @@ class Shells {
     }
 
   }
+  info() {
+    return this.shells.map((s) => {
+      return {
+        EOL: s.EOL,
+        shell: s.shell,
+        args: s.args,
+        cols: s.cols,
+        rows: s.rows,
+        id: s.id,
+        group: s.group,
+        start_time: s.start_time,
+        cmd: s.cmd,
+        done: s.done,
+        state: s.state
+      }
+    })
+  }
   async launch(params, options, ondata) {
     // if array, duplicate the action
     if (Array.isArray(params.message)) {
@@ -96,7 +113,10 @@ class Shells {
     let cwd = (options && options.cwd ? options.cwd : this.kernel.homedir)   // if cwd exists, use it. Otherwise the cwd is pinokio home folder (~/pinokio)              
     params.path = this.kernel.api.resolvePath(cwd, exec_path)
     let sh = new Shell(this.kernel)
-    if (options) params.group = options.group  // set group
+    if (options) {
+      params.group = options.group  // set group
+      params.$title = options.title
+    }
 
     let m
     let matched_index

package/kernel/util.js

@@ -212,9 +212,9 @@ const exists= (abspath) => {
 }
 const log = async (filepath, str, session) => {
   if (str && str.trim().length > 0) {
-    try {
+    let e = await exists(filepath)
+    if (!e) {
       await fs.promises.mkdir(filepath, { recursive: true })
-    } catch (e) {
     }
 
     let output = '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "3.86.0",
+  "version": "3.87.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -68,6 +68,7 @@
     "portfinder-cp": "^1.0.34",
     "proxy-agent": "^6.5.0",
     "qrcode": "^1.5.3",
+    "querystring": "^0.2.1",
     "random-useragent": "^0.5.0",
     "rimraf": "^5.0.0",
     "sanitize-filename": "^1.6.3",

package/script/install-mode.js

@@ -0,0 +1,33 @@
+const path = require('path')
+const Kernel = require('../kernel')
+
+async function main() {
+  const mode = process.env.PINOKIO_SETUP_MODE || 'prod_dev'
+  const home = process.env.PINOKIO_HOME || path.resolve(process.cwd(), '.pinokio')
+
+  console.log(`[seed] mode=${mode} home=${home}`)
+
+  const kernel = new Kernel({ store: {} })
+  await kernel.init({})
+  await kernel.shell.init()
+  await kernel.bin.init()
+  await kernel.bin.refreshInstalled()
+
+  if (kernel.refresh_interval) {
+    clearInterval(kernel.refresh_interval)
+  }
+  kernel.server_running = true
+
+  await kernel.bin.check({ bin: kernel.bin.preset(mode) })
+  await kernel.bin.install({ mode }, () => {})
+  if (kernel.refresh_interval) {
+    clearInterval(kernel.refresh_interval)
+  }
+  console.log('[seed] completed')
+  process.exit(0)
+}
+
+main().catch((error) => {
+  console.error('[seed] failed', error)
+  process.exit(1)
+})

package/script/pinokio.json

@@ -0,0 +1,7 @@
+{
+  "theme": "light",
+  "version": "3.86.0",
+  "HTTP_PROXY": "",
+  "HTTPS_PROXY": "",
+  "NO_PROXY": ""
+}