pinokiod 3.2.221 → 3.2.223

package/kernel/api/index.js

@@ -24,6 +24,8 @@ class Api {
     this.done = {}
     this.waiter = {}
     this.proxies = {}
+    this.mods = {}
+    this.child_procs = {}
     this.lproxy = new Lproxy()
   }
   get_proxy_url(root, port) {
@@ -125,12 +127,26 @@ class Api {
 
 
     let { cwd, script } = await this.resolveScript(requestPath)
+    console.log("STOP", { script })
     if (script.on) {
       if (script.on.stop) {
         await this.process(script.on.stop) 
       }
     }
 
+    // reset modules
+    let modpath = this.resolvePath(cwd, req.params.uri)
+    console.log("STOP modpath", modpath)
+    console.log("this.mods before", this.mods)
+    console.log("this.child_procs before", this.child_procs)
+    let child_procs = Array.from(this.child_procs[modpath])
+    for(let proc of child_procs) {
+      console.log("reset child proc", proc)
+      delete this.mods[proc]
+    }
+    delete this.child_procs[modpath]
+    console.log("this.mods after", this.mods)
+    console.log("this.child_procs after", this.child_procs)
 
 
     // stop all shell processes connected to the uri
@@ -411,6 +427,34 @@ class Api {
     if (req.uri) {
       modpath = this.resolvePath(cwd, req.uri)
       let m = (await this.loader.load(modpath))
+      const stats = await fs.promises.stat(modpath)
+      if (!this.child_procs[req.parent.path]) {
+        this.child_procs[req.parent.path] = new Set()
+      }
+      console.log("SCRIPT RESOLVE METHOD", req)
+      if (this.mods[modpath]) {
+        // use the cached module if unchanged
+        if (String(stats.mtime) === String(this.mods[modpath].updated)) {
+          console.log("NOT UPDATED. Use the cached version")
+          m = this.mods[modpath].mod
+        } else {
+          console.log("UPDATED. Use the Reloaded version")
+          this.child_procs[req.parent.path].add(modpath)
+          this.mods[modpath] = {
+            mod: m,
+            updated: String(stats.mtime),
+          }
+        }
+      } else {
+        console.log("NEW. Load for the first time")
+        // cache the mods so the module can be stateful
+        // the modules can set attributes on itself
+        this.child_procs[req.parent.path].add(modpath)
+        this.mods[modpath] = {
+          mod: m,
+          updated: String(stats.mtime),
+        }
+      }
       mod = m.resolved
       dirname = m.dirname
       method = mod[req.method].bind(mod)
@@ -589,6 +633,12 @@ class Api {
     // 6. rpc must have method names
     if (rpc.method) {
 
+      rpc.parent = {
+        uri: request.uri,
+        path: request.path,
+        git: this.parentGitURI(request.path),
+        body: script 
+      }
       // 7. resolve the rpc
       let resolved = await this.resolveMethod(rpc, cwd)
 
@@ -611,12 +661,12 @@ class Api {
 
         rpc.root = request.uri
 
-        rpc.parent = {
-          uri: request.uri,
-          path: request.path,
-          git: this.parentGitURI(request.path),
-          body: script 
-        }
+//        rpc.parent = {
+//          uri: request.uri,
+//          path: request.path,
+//          git: this.parentGitURI(request.path),
+//          body: script 
+//        }
 
         if (request.client) rpc.client = request.client
 
@@ -670,7 +720,16 @@ class Api {
           } else {
             should_run = false
           }
+
           if (!should_run) {
+            // the current step is skipped, therefore the next value should be ignored as well
+            if (i < script.run.length-1) {
+              rpc.next = i+1
+            } else {
+              rpc.next = null
+            }
+
+
           //if (!rpc.when) {
             if (typeof rpc.next === "undefined" || rpc.next === null) {
               // last call

package/kernel/api/script/index.js

@@ -41,19 +41,28 @@ class Script {
         - absolute path
         - http path
     */
-    let uri = await this.download(req, ondata, kernel)
-    let res = await new Promise((resolve, reject) => {
-      kernel.api.process({
-        uri,
-        input: req.params.params,
-        client: req.client,
-        caller: req.parent.path,
-      }, (r) => {
-        resolve(r.input)
+    // if already running, print that it's already running
+    let id = kernel.api.filePath(req.params.uri, req.cwd)
+    if (kernel.api.running[id]) {
+      let msg = `${req.params.uri} already running. Continuing...\r\n`
+      ondata({ raw: msg })
+    } else {
+      // if not already running, start.
+      let uri = await this.download(req, ondata, kernel)
+      let res = await new Promise((resolve, reject) => {
+        kernel.api.process({
+          uri,
+          input: req.params.params,
+          client: req.client,
+          caller: req.parent.path,
+        }, (r) => {
+          resolve(r.input)
+        })
       })
-    })
-    // need to call api.linkGit() so the git repositories list is up to date
-    return res
+      // need to call api.linkGit() so the git repositories list is up to date
+      return res
+    }
+
   }
   async return(req, ondata, kernel) {
     /*

package/kernel/bin/index.js

@@ -391,9 +391,10 @@ class Bin {
       console.log({ brew_path, brew_exists })
 
       let brew = []
+      console.time(">0")
       if (brew_exists) {
         start = false
-        res = await this.exec({ message: `brew list -1` }, (stream) => {
+        res = await this.exec({ message: `brew list -1`, conda: { skip: true } }, (stream) => {
 //          console.log("brew list check", { stream })
         })
         console.log("BREW", res.response)
@@ -416,15 +417,18 @@ class Bin {
           }
         }
       }
+      console.timeEnd(">0")
       this.installed.brew = new Set(brew)
 
 
       // check brew_installed
       console.log("checking brew installed")
+      console.time(">1")
       let e = await this.kernel.bin.exists("homebrew")
-      let { stdout }= await this.exec({ message: "xcode-select -p" }, (stream) => { })
+      let { stdout }= await this.exec({ message: "xcode-select -p", conda: { skip: true } }, (stream) => { })
       let e2 = /(.*Library.*Developer.*CommandLineTools.*|.*Xcode.*Developer.*)/gi.test(stdout)
       let e3 = await this.kernel.exists("/Library/Developer/CommandLineTools")
+      console.timeEnd(">1")
 
       // if xcode-select version exists
       // - if version is greater thatn 2349 => yes
@@ -433,7 +437,8 @@ class Bin {
       // - no
 
       let e4;
-      let result = await this.exec({ message: "xcode-select --version" }, (stream) => { })
+      console.time(">2")
+      let result = await this.exec({ message: "xcode-select --version", conda: { skip: true } }, (stream) => { })
       if (result && result.stdout) {
         e4 = /xcode-select version ([0-9]+)/gi.exec(result.stdout)
         if (e4 && e4.length > 1) {
@@ -450,6 +455,7 @@ class Bin {
       } else {
         e4 = false
       }
+      console.timeEnd(">2")
       console.log("BREW CHECK", { e, e2, e3, e4 })
       this.brew_installed = e && e2 && e3 && e4
 

package/kernel/environment.js

@@ -103,6 +103,19 @@ const ENVS = async () => {
       "#",
       "##########################################################################",
     ],
+  }, {
+    type: ["app"],
+    key: "PINOKIO_SCRIPT_AUTOLAUNCH",
+    val: "true",
+    comment: [
+      "##########################################################################",
+      "#",
+      "# PINOKIO_SCRIPT_AUTOLAUNCH",
+      "# the relative file path for auto launching any script",
+      "# the specified script will automatically run when pinokio first launches",
+      "#",
+      "##########################################################################",
+    ]
   }, {
     type: ["system"],
     key: "PINOKIO_SHARE_VAR",

package/kernel/index.js

@@ -1,6 +1,7 @@
 const fs = require('fs')
 const os = require("os")
 const jsdom = require("jsdom");
+const randomUseragent = require('random-useragent');
 const path = require('path')
 const fastq = require('fastq')
 const fetch = require('cross-fetch');
@@ -88,6 +89,15 @@ class Kernel {
     }
     return Environment.get2(folderpath, this)
   }
+  async userAgent(browser) {
+    if (browser) {
+      return randomUseragent.getRandom((ua) => {
+        return ua.browserName === browser;
+      });
+    } else {
+      return randomUseragent.getRandom()
+    }
+  }
   resumeprocess(uri) {
     let proc = this.procs[uri]
     if (proc && proc.resolve) {
@@ -100,6 +110,7 @@ class Kernel {
       type := "local" | "global"
     */
     let o = {}
+    console.log("IMPORT", params)
     for(let key in params) {
       // get memory for each uri
       let uri = params[key]
@@ -478,6 +489,27 @@ class Kernel {
                   }
                 }
               })
+
+              // get env
+              for(let api of this.i.api) {
+                let env_path = path.resolve(this.api.userdir, api.path)
+                let e = await Environment.get(env_path)
+                console.log(e)
+                if (e.PINOKIO_SCRIPT_AUTOLAUNCH) {
+                  let autolaunch_path = path.resolve(env_path, e.PINOKIO_SCRIPT_AUTOLAUNCH)
+                  console.log("AUTOLAUNCHING", autolaunch_path)
+                  let res = await new Promise((resolve, reject) => {
+                    this.api.process({
+                      uri: autolaunch_path,
+                      input: {}
+      //                client: req.client,
+      //                caller: req.parent.path,
+                    }, (r) => {
+                      resolve(r.input)
+                    })
+                  })
+                }
+              }
             }
 //            console.log({ grant_permission })
 //            if (grant_permission) {
@@ -520,6 +552,7 @@ class Kernel {
 
         await fs.promises.mkdir(this.path("logs"), { recursive: true }).catch((e) => { })
         await fs.promises.writeFile(this.path("logs/system.json"), JSON.stringify(this.i, null, 2))
+
       /*
         this.sys = new Sysinfo()
         await this.sys.init(this)

package/kernel/shell.js

@@ -788,6 +788,7 @@ class Shell {
   async exec(params) {
     params = await this.activate(params)
     this.cmd = this.build(params)
+    console.log("this.cmd", this.cmd)
     let res = await new Promise((resolve, reject) => {
       this.resolve = resolve
       this.reject = reject

package/package.json

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