pinokiod 7.2.11 → 7.2.13

package/Dockerfile

@@ -37,8 +37,6 @@ RUN mkdir -p /app/.pinokio-seed \
     && rm -rf /app/.pinokio-seed/network/system/.git \
     && rm -rf /app/.pinokio-seed/plugin \
     && mkdir -p /app/.pinokio-seed/plugin \
-    && git clone --depth 1 https://github.com/pinokiocomputer/code /app/.pinokio-seed/plugin/code \
-    && rm -rf /app/.pinokio-seed/plugin/code/.git \
     && rm -rf /app/.pinokio-seed/prototype/system \
     && mkdir -p /app/.pinokio-seed/prototype \
     && git clone --depth 1 https://github.com/pinokiocomputer/proto /app/.pinokio-seed/prototype/system \

package/kernel/api/index.js

@@ -29,6 +29,19 @@ class Api {
     this.child_procs = {}
     this.lproxy = new Lproxy()
   }
+  startData(rpc) {
+    if (rpc && rpc.method === "process.wait" && rpc.params && typeof rpc.params === "object" && !Array.isArray(rpc.params)) {
+      let data = rpc
+      if (typeof data.title === "undefined" && typeof rpc.params.title !== "undefined") {
+        data = { ...data, title: rpc.params.title }
+      }
+      if (typeof data.description === "undefined" && typeof rpc.params.description !== "undefined") {
+        data = { ...data, description: rpc.params.description }
+      }
+      return data
+    }
+    return rpc
+  }
   async launcher_path(name) {
     let root_path = this.kernel.path("api", name)
     let primary_path = path.resolve(root_path, "pinokio.js")
@@ -1186,7 +1199,7 @@ class Api {
           this.ondata({
             id: request.id || request.path,
             type: "start",
-            data: rpc
+            data: this.startData(rpc)
           })
 
           // DEPRECATED APIS

package/kernel/api/process/index.js

@@ -34,6 +34,16 @@ class Process {
   constructor() {
     this.appApi = new AppAPI()
   }
+  async waitIndefinitely(req, kernel) {
+    await new Promise((resolve, reject) => {
+      this.resolve = resolve
+
+      // register the process with the root uri so it can be manually resolved (with this.resolve()) later
+      if (kernel && kernel.procs && req && req.parent && req.parent.path) {
+        kernel.procs[req.parent.path] = this
+      }
+    })
+  }
 //  async start(req, ondata, kernel) {
 //    /*
 //      req := {
@@ -159,6 +169,8 @@ class Process {
     /*
     params := {
       sec: <SECONDS>,
+      title: (optional) Title to display in the footer while waiting,
+      description: (optional) Description to display in the footer while waiting,
       message: (optional) Description to display while waiting,
       menu: (optional) menu to display in the modal while waiting,
 //      ok: (optional) <ok button text> (if not specified, no ok button),
@@ -169,6 +181,8 @@ class Process {
 
     params := {
       min: <MINUTES>,
+      title: (optional) Title to display in the footer while waiting,
+      description: (optional) Description to display in the footer while waiting,
       message: (optional) Description to display while waiting,
       menu: (optional) menu to display in the modal while waiting,
 //      ok: (optional) <ok button text> (if not specified, no ok button),
@@ -180,6 +194,8 @@ class Process {
     params := {
       url: <URL>,
       interval: (optional) how often to retry checking (in seconds)
+      title: (optional) Title to display in the footer while waiting,
+      description: (optional) Description to display in the footer while waiting,
       message: (optional) the message to display while retrying (default: no message)
     }
 
@@ -198,9 +214,21 @@ class Process {
 
     or
 
+    params := {
+      title: (optional) Title to display in the footer while waiting,
+      description: (optional) Description to display in the footer while waiting,
+    }
+
+    This waits indefinitely until the script is stopped or the wait is manually
+    resolved.
+
+    or
+
 
     params := {
       on: <wait-on condition https://github.com/jeffbski/wait-on>,
+      title: (optional) Title to display in the footer while waiting,
+      description: (optional) Description to display in the footer while waiting,
       message: (optional) Description to display while waiting,
       menu: (optional) menu to display in the modal while waiting,
 //      ok: (optional) <ok button text> (if not specified, no ok button),
@@ -212,57 +240,84 @@ class Process {
     if 'cancel' is pressed before the condition is met, stops the script
 
     */
-    let ms 
-    if (req.params) {
-      if (req.params.app || req.params.id || req.params.name) {
-        await this.appApi.waitForAppPresence(req, ondata, kernel)
-        return
+    let ms
+    const waitPath = req && req.parent && req.parent.path
+    if (waitPath && kernel) {
+      if (!kernel.activeProcessWaits) {
+        kernel.activeProcessWaits = {}
       }
-      // Display modal
-      if (req.params.sec || req.params.min) {
-        // Wait
-        if (req.params.sec) {
-          ms = req.params.sec * 1000
-        } else if (req.params.min) {
-          ms = req.params.min * 60 * 1000
+      kernel.activeProcessWaits[waitPath] = {
+        path: waitPath,
+        params: req.params || {},
+        title: req.params && req.params.title,
+        description: req.params && req.params.description,
+        message: req.params && req.params.message,
+        started: Date.now()
+      }
+    }
+    const showFooter = req.params && (req.params.title || req.params.description)
+    if (showFooter && typeof ondata === "function") {
+      ondata(req.params, "process.wait.start")
+    }
+    try {
+      if (req.params) {
+        if (req.params.app || req.params.id || req.params.name) {
+          await this.appApi.waitForAppPresence(req, ondata, kernel)
+          return
         }
-        await new Promise((resolve, reject) => {
-          this.resolve = resolve
+        // Display modal
+        if (req.params.sec || req.params.min) {
+          // Wait
+          if (req.params.sec) {
+            ms = req.params.sec * 1000
+          } else if (req.params.min) {
+            ms = req.params.min * 60 * 1000
+          }
+          await new Promise((resolve, reject) => {
+            this.resolve = resolve
 
-          // register the process with the root uri so it can be manually resolved (with this.resolve()) later
-          kernel.procs[req.parent.path] = this
+            // register the process with the root uri so it can be manually resolved (with this.resolve()) later
+            kernel.procs[req.parent.path] = this
 
-          setTimeout(() => {
-            this.resolve()
-          }, ms)
-        })
-      } else if (req.params.uri) {
-        let interval = req.params.interval ? req.params.interval * 1000 : 1000
-        ondata(req.params, "loading.start")
-        await waitForUrl(req.params.uri, req.params.message, interval, ondata)
-        ondata(req.params, "loading.end")
-      } else if (req.params.url) {
-        let interval = req.params.interval ? req.params.interval * 1000 : 1000
-        ondata(req.params, "loading.start")
-        await waitForUrl(req.params.url, req.params.message, interval, ondata)
-        ondata(req.params, "loading.end")
-      } else if (req.params.on) {
-        // Wait
-        if (req.params.message) {
-          ondata({
-            raw: `\r\nWaiting: ${JSON.stringify(req.params.on)}\r\n`
+            setTimeout(() => {
+              this.resolve()
+            }, ms)
           })
-          ondata(req.params, "wait")
+        } else if (req.params.uri) {
+          let interval = req.params.interval ? req.params.interval * 1000 : 1000
+          ondata(req.params, "loading.start")
+          await waitForUrl(req.params.uri, req.params.message, interval, ondata)
+          ondata(req.params, "loading.end")
+        } else if (req.params.url) {
+          let interval = req.params.interval ? req.params.interval * 1000 : 1000
+          ondata(req.params, "loading.start")
+          await waitForUrl(req.params.url, req.params.message, interval, ondata)
+          ondata(req.params, "loading.end")
+        } else if (req.params.on) {
+          // Wait
+          if (req.params.message) {
+            ondata({
+              raw: `\r\nWaiting: ${JSON.stringify(req.params.on)}\r\n`
+            })
+            ondata(req.params, "wait")
+          }
+          console.log("Wait", req.params.on)
+          await waitOn(req.params.on)
+          console.log("Wait finished")
+          ondata(req.params, "wait.end")
+        } else {
+          await this.waitIndefinitely(req, kernel)
         }
-        console.log("Wait", req.params.on)
-        await waitOn(req.params.on)
-        console.log("Wait finished")
-        ondata(req.params, "wait.end")
+      } else {
+        await this.waitIndefinitely(req, kernel)
+      }
+    } finally {
+      if (waitPath && kernel && kernel.activeProcessWaits) {
+        delete kernel.activeProcessWaits[waitPath]
+      }
+      if (showFooter && typeof ondata === "function") {
+        ondata(req.params, "process.wait.end")
       }
-    } else {
-      await new Promise((resolve, reject) => {
-        this.resolve = resolve
-      })
     }
   }
 }

package/kernel/api/uri/index.js

@@ -0,0 +1,51 @@
+const Util = require('../../util')
+
+const appendQueryParams = (uri, params) => {
+  if (!params || typeof params !== 'object' || Array.isArray(params)) {
+    return uri
+  }
+
+  const entries = []
+  for (const [key, value] of Object.entries(params)) {
+    const values = Array.isArray(value) ? value : [value]
+    for (const item of values) {
+      if (item === undefined || item === null) {
+        continue
+      }
+      const serialized = typeof item === 'object' ? JSON.stringify(item) : String(item)
+      entries.push(`${encodeURIComponent(key)}=${encodeURIComponent(serialized)}`)
+    }
+  }
+
+  if (entries.length === 0) {
+    return uri
+  }
+
+  const hashIndex = uri.indexOf('#')
+  const base = hashIndex === -1 ? uri : uri.slice(0, hashIndex)
+  const hash = hashIndex === -1 ? '' : uri.slice(hashIndex)
+  const separator = base.includes('?')
+    ? (base.endsWith('?') || base.endsWith('&') ? '' : '&')
+    : '?'
+
+  return `${base}${separator}${entries.join('&')}${hash}`
+}
+
+class URI {
+  build(params = {}) {
+    const uri = typeof params.uri === 'string' ? params.uri.trim() : ''
+    if (!uri) {
+      throw new Error('uri.open requires params.uri')
+    }
+    return appendQueryParams(uri, params.params)
+  }
+
+  async open(req, ondata, kernel) {
+    const uri = this.build(req.params)
+    ondata({ raw: `\r\nopening uri: ${uri}\r\n` })
+    const result = await Util.openURI(uri)
+    return { uri, result }
+  }
+}
+
+module.exports = URI

package/kernel/environment.js

@@ -72,7 +72,7 @@ const managedCacheEnvDefaults = () => {
   return defaults
 }
 
-const ensureCachePreflightDir = async (key, targetPath) => {
+const ensureCachePreflightDir = async (key, targetPath, options = {}) => {
   logCachePreflight(`${key}: target=${targetPath}`)
   try {
     await fs.promises.mkdir(targetPath, { recursive: true })
@@ -95,7 +95,26 @@ const ensureCachePreflightDir = async (key, targetPath) => {
     logCachePreflight(`${key}: repair delete ok`)
   } catch (error) {
     logCachePreflight(`${key}: repair delete failed ${formatCachePreflightError(error)}`)
-    return { key, path: targetPath, repaired: false, ok: false, step: "repair delete", error }
+    if (typeof options.elevatedRepair !== "function") {
+      return { key, path: targetPath, repaired: false, ok: false, step: "repair delete", error }
+    }
+    logCachePreflight(`${key}: elevated repair start path=${targetPath}`)
+    let elevatedRepair
+    try {
+      elevatedRepair = await options.elevatedRepair(targetPath, logCachePreflight)
+    } catch (repairError) {
+      elevatedRepair = { ok: false, error: repairError }
+    }
+    if (!elevatedRepair || !elevatedRepair.ok) {
+      return { key, path: targetPath, repaired: false, elevated: true, ok: false, step: "elevated repair", error: elevatedRepair && elevatedRepair.error ? elevatedRepair.error : error }
+    }
+    const elevatedProbe = await probeCacheDir(targetPath)
+    if (elevatedProbe.ok) {
+      logCachePreflight(`${key}: elevated repair probe ok`)
+      return { key, path: targetPath, repaired: true, elevated: true, ok: true }
+    }
+    logCachePreflight(`${key}: elevated repair probe failed step="${elevatedProbe.step}" ${formatCachePreflightError(elevatedProbe.error)}`)
+    return { key, path: targetPath, repaired: true, elevated: true, ok: false, step: elevatedProbe.step, error: elevatedProbe.error }
   }
 
   try {
@@ -140,7 +159,7 @@ const ensurePinokioCacheDirs = async (kernel, options = {}) => {
 
   for (const key of CACHE_PREFLIGHT_KEYS) {
     const targetPath = path.resolve(cacheRoot, key)
-    const result = await ensureCachePreflightDir(key, targetPath)
+    const result = await ensureCachePreflightDir(key, targetPath, options)
     results.push(result)
     if (!result.ok) {
       errors.push(result)

package/kernel/git.js

@@ -1378,19 +1378,6 @@ class Git {
     const absoluteTarget = path.resolve(targetPath)
     const home = path.resolve(this.kernel.homedir)
     const managedTargets = [
-      {
-        kind: "plugin",
-        root: path.resolve(home, "plugin/code"),
-        matches: (root, target) => target === root || target.startsWith(`${root}${path.sep}`),
-        bootstrap: async () => {
-          await fs.promises.rm(path.resolve(home, "plugin/code"), { recursive: true, force: true })
-          this.dirs.delete(path.resolve(home, "plugin/code"))
-          if (this.kernel.plugin && typeof this.kernel.plugin.init === "function") {
-            await this.kernel.plugin.init()
-          }
-        },
-        exists: async () => this.kernel.exists("plugin/code")
-      },
       {
         kind: "prototype",
         root: path.resolve(home, "prototype/system"),

package/kernel/index.js

@@ -44,6 +44,7 @@ const WatchManager = require('./watch')
 const { DownloaderHelper } = require('node-downloader-helper');
 const { ProxyAgent } = require('proxy-agent');
 const fakeUa = require('fake-useragent');
+const sudo = process.platform === "win32" ? require("sudo-prompt-programfiles-x86") : null
 //const kill = require('./tree-kill');
 const kill = require('kill-sync')
 const ejs = require('ejs');
@@ -55,6 +56,34 @@ const VARS = {
   }
 }
 
+const powershellSingleQuote = (value) => {
+  return `'${String(value).replace(/'/g, "''")}'`
+}
+
+const windowsCacheRepairCommand = (targetPath) => {
+  const psPath = powershellSingleQuote(targetPath)
+  return [
+    "powershell.exe",
+    "-NoProfile",
+    "-ExecutionPolicy Bypass",
+    "-Command",
+    `"`,
+    "$ErrorActionPreference = 'Stop';",
+    `$p = ${psPath};`,
+    "$account = [System.Security.Principal.WindowsIdentity]::GetCurrent().Name;",
+    "$grant = $account + ':(OI)(CI)F';",
+    "if (Test-Path -LiteralPath $p) {",
+    "  & takeown.exe /F $p /R /D Y;",
+    "  & icacls.exe $p /reset /T /C;",
+    "  & icacls.exe $p /grant $grant /T /C;",
+    "  Remove-Item -LiteralPath $p -Recurse -Force;",
+    "}",
+    "New-Item -ItemType Directory -Force -Path $p | Out-Null;",
+    "& icacls.exe $p /grant $grant /T /C;",
+    `"`
+  ].join(" ")
+}
+
 //const memwatch = require('@airbnb/node-memwatch');
 class Kernel {
   schema = "<=7.0.0"
@@ -386,6 +415,9 @@ class Kernel {
   path(...args) {
     return path.resolve(this.homedir, ...args)
   }
+  systemPath(...args) {
+    return path.resolve(__dirname, "..", "system", ...args)
+  }
   exists(...args) {
     if (args) {
       let abspath = this.path(...args)
@@ -465,6 +497,30 @@ class Kernel {
       return ''
     }
   }
+  async elevatedCacheRepair(targetPath, log = console.log) {
+    if (this.platform !== "win32" || !sudo) {
+      return { ok: false, error: new Error("Elevated cache repair is only available on Windows") }
+    }
+    const command = windowsCacheRepairCommand(targetPath)
+    log(`elevated repair command=${command}`)
+    return new Promise((resolve) => {
+      sudo.exec(command, { name: "Pinokio" }, (error, stdout, stderr) => {
+        if (stdout && stdout.trim()) {
+          log(`elevated repair stdout ${stdout.trim()}`)
+        }
+        if (stderr && stderr.trim()) {
+          log(`elevated repair stderr ${stderr.trim()}`)
+        }
+        if (error) {
+          log(`elevated repair failed ${error.message || error}`)
+          resolve({ ok: false, error, stdout, stderr })
+        } else {
+          log(`elevated repair ok path=${targetPath}`)
+          resolve({ ok: true, stdout, stderr })
+        }
+      })
+    })
+  }
   async ensureRouterMode() {
     const domain = await this.resolvePinokioDomain()
     const shouldUseCustom = domain.length > 0
@@ -1007,6 +1063,7 @@ class Kernel {
       args: {},
     }
     this.procs = {}
+    this.activeProcessWaits = {}
     this.template = new Template()
     try {
       if (this.homedir) {
@@ -1053,7 +1110,10 @@ class Kernel {
 
         // 2. mkdir all the folders if not already created
         await Environment.init_folders(this.homedir, this)
-        await Environment.ensurePinokioCacheDirs(this)
+        await Environment.ensurePinokioCacheDirs(this, {
+          throwOnFailure: true,
+          elevatedRepair: this.elevatedCacheRepair.bind(this)
+        })
 
         // if key.json doesn't exist, create an empty json file
         let ee = await this.exists(this.homedir, "key.json")

package/kernel/plugin.js

@@ -1,39 +1,14 @@
-const path = require('path')
-const { glob } = require('glob')
-const Info = require("./info")
+const fs = require('fs')
+const PluginSources = require("./plugin_sources")
+
 class Plugin {
   constructor(kernel) {
     this.kernel = kernel
   }
   async setConfig() {
-    let plugin_dir = path.resolve(this.kernel.homedir, "plugin")
     this.cache = {}
 
-    let plugin_paths = await glob('**/pinokio.js', { cwd: plugin_dir })
-
-    let plugins = []
-    for(let plugin_path of plugin_paths) {
-      let config = await this.kernel.require(path.resolve(plugin_dir, plugin_path))
-      if (config && config.run && Array.isArray(config.run)) {
-        let invalid
-        for(let key in config) {
-          if (typeof config[key] === "function") {
-            invalid = true
-          }
-        }
-        if (invalid) {
-          continue
-        }
-
-        let chunks = plugin_path.split(path.sep)
-        let cwd = chunks.slice(0, -1).join("/")
-        config.image = "/asset/plugin/" + cwd + "/" + config.icon 
-        plugins.push({
-          href: "/run/plugin/" + chunks.join("/"),
-          ...config
-        })
-      }
-    }
+    const plugins = await PluginSources.loadPluginMenu(this.kernel)
 
     this.config = {
       menu: plugins.map((plugin) => {
@@ -48,37 +23,10 @@ class Plugin {
     if (!exists) {
       await fs.promises.mkdir(this.kernel.path("plugin"), { recursive: true }).catch((e) => {})
     }
-    let code_exists = await this.kernel.exists("plugin/code")
-    console.log({ code_exists })
-    if (!code_exists) {
-      if (this.kernel.bin.installed && this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git")) {
-        await this.kernel.exec({
-          //message: "git clone https://github.com/peanutcocktail/plugin",
-          //message: "git clone https://github.com/pinokiocomputer/plugin",
-          message: "git clone https://github.com/pinokiocomputer/code",
-          path: this.kernel.path("plugin")
-        }, (e) => {
-          process.stdout.write(e.raw)
-        })
-        await this.setConfig()
-        return
-      }
-    } else {
-      await this.setConfig()
-    }
+    await this.setConfig()
   }
   async update() {
-    if (this.kernel.bin.installed && this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git")) {
-      let exists = await this.kernel.exists("plugin")
-      if (!exists) {
-        await this.kernel.exec({
-          message: "git pull",
-          path: this.kernel.path("plugin")
-        }, (e) => {
-          process.stdout.write(e.raw)
-        })
-      }
-    }
+    await this.setConfig()
   }
 }
 module.exports = Plugin