pinokiod 1.3.40 → 1.3.41

package/kernel/api/cloudflare/index.js

@@ -24,7 +24,6 @@ class C {
     let options = {}
     if (req.cwd) options.cwd = req.cwd
     if (req.parent && req.parent.path) options.group = req.parent.path
-    console.log("shells before", kernel.shell.shells)
     let pattern = /(https:.+?trycloudflare\.com)/
     let cloudflare_url = await new Promise((resolve, reject) => {
       kernel.shell.start(params, options, (e) => {
@@ -35,9 +34,8 @@ class C {
         }
       })
     })
-    console.log("cloudflare_url", cloudflare_url)
 
-    ondata({ raw: yellow("\r\n## Scan the QR code to open in any device\r\n\r\n") })
+    ondata({ raw: yellow("\r\n## [CLOUDFLARE SHARING] Scan the QR code to open in any device\r\n\r\n") })
     ondata({ raw: blue(`${cloudflare_url}\r\n\r\n`) })
 
     await new Promise((resolve, reject) => {

package/kernel/api/fs/index.js

@@ -9,7 +9,8 @@ const randomUseragent = require('random-useragent');
 const symlinkDir = require('symlink-dir')
 const retry = require('async-retry');
 const { createHash } = require('crypto');
-
+const Environment = require("../../environment")
+const Util = require("../../util")
 
 const log = (msgs, ondata) => {
   for(let msg of msgs) {
@@ -127,6 +128,22 @@ class FS {
 
     ondata({ raw: "\r\ncreating a shared drive:\r\n" + JSON.stringify(req.params, null, 2).replace(/\n/g, "\r\n") })
 
+
+    let api_path = await Util.api_path(req.parent.path, kernel)
+    let current_env = await Environment.get(api_path)
+    let default_env = await Environment.get(kernel.homedir)
+    current_env = Object.assign(process.env, default_env, current_env)
+
+    let env_drive_path = current_env.PINOKIO_DRIVE
+    let drive_home
+    if (env_drive_path) {
+      let api_path = `${kernel.homedir}${path.sep}api`
+      let rel_path = path.relative(api_path, req.parent.path)
+      let api_name = rel_path.split(path.sep)[0]
+      let current_api_path = `${api_path}${path.sep}${api_name}`
+      drive_home = path.resolve(current_api_path, env_drive_path)
+    }
+
     if (req.params.venv) {
       // pip sharing
       // 1. get all pip items
@@ -150,7 +167,7 @@ class FS {
       // symlink:
       //  from => :package_path
       //  to => /drives/packages/pip/:package_name/:package_version
-      const drivePath = kernel.path("drive")
+      const drivePath = drive_home || kernel.path("drive")
       const drive = new Pdrive(drivePath)
       for(let name in res) {
         /*
@@ -259,10 +276,18 @@ class FS {
           }
 
           for(let relpath of copy) {
-            d.copy[relpath] = kernel.path("drive", p, relpath)
+            if (drive_home) {
+              d.copy[relpath] = path.resolve(drive_home, p, relpath)
+            } else {
+              d.copy[relpath] = kernel.path("drive", p, relpath)
+            }
           }
           for(let relpath of move) {
-            d.move[relpath] = kernel.path("drive", p, relpath)
+            if (drive_home) {
+              d.move[relpath] = path.resolve(drive_home, p, relpath)
+            } else {
+              d.move[relpath] = kernel.path("drive", p, relpath)
+            }
           }
           ondata({
             raw: "\r\nLINKING DRIVES:\r\n" + JSON.stringify(d, null, 2).replace(/\n/g, "\r\n")
@@ -279,7 +304,7 @@ class FS {
 
       }
     } else if (req.params.drive) {
-      const drivePath = kernel.path("drive")
+      const drivePath = drive_home || kernel.path("drive")
       const drive = new Pdrive(drivePath)
       for(const route in req.params.drive) {
         const link = req.params.drive[route]

package/kernel/api/index.js

@@ -560,6 +560,7 @@ class Api {
     // 6. rpc must have method names
     if (rpc.method) {
 
+
       // 7. resolve the rpc
       let resolved = await this.resolveMethod(rpc, cwd)
 
@@ -666,31 +667,46 @@ class Api {
             data: rpc
           })
 
-          // 11. actually make the rpc call
-          let result = await this.run(resolved.method, rpc, (stream, type) => {
-            let m = {
-              id: request.path,
-              caller: request.caller,
-              type: (type ? type : "stream"),
-              index: i,
-              total,
-              data: stream,
-              rpc,
-              rawrpc
-            }
+          // DEPRECATED APIS
+          // If deprecated, just ignore and move on
+          const deprecated = [
+            "proxy.start"
+          ]
+
+
+          let result
+          if (deprecated.includes(rpc.method)) {
+            const msg = `DEPRECATED API ${rpc.method}. Ignored`
+            console.log(msg)
+          } else {
+            // 11. actually make the rpc call
+            result = await this.run(resolved.method, rpc, (stream, type) => {
+              let m = {
+                id: request.path,
+                caller: request.caller,
+                type: (type ? type : "stream"),
+                index: i,
+                total,
+                data: stream,
+                rpc,
+                rawrpc
+              }
+
+  //            if (["input", "modal"].includes(m.type)) {
+  //              // if a message requires user feedback, do not modify id
+  //            } else {
+  //              // if a message does not require user feedback
+  //              // if the current session has a "caller" (parent process),
+  //              // set the id to request.caller so the terminal prints the logs
+  //              if (request.caller) {
+  //                m.id = request.caller
+  //              }
+  //            }
+              this.ondata(m)
+            })
+          }
+
 
-//            if (["input", "modal"].includes(m.type)) {
-//              // if a message requires user feedback, do not modify id
-//            } else {
-//              // if a message does not require user feedback
-//              // if the current session has a "caller" (parent process),
-//              // set the id to request.caller so the terminal prints the logs
-//              if (request.caller) {
-//                m.id = request.caller
-//              }
-//            }
-            this.ondata(m)
-          })
 
           if (result && rpc.returns) {
             // set the scope variable from the return value

package/kernel/api/local/index.js

@@ -1,5 +1,9 @@
 const set = require("../set")
 const rm = require("../rm")
+const Cloudflare = require("../cloudflare")
+const Proxy = require('../proxy')
+const Environment = require('../../environment')
+const Util = require("../../util")
 class Local {
   async import(req, ondata, kernel) {
     /*
@@ -48,6 +52,45 @@ class Local {
       }
     })
     let res = await set(converted, ondata, kernel)
+
+    // handle special local variables
+    /*
+      req :- {
+        method: "set",
+        params: {
+          "url": k
+        }
+      }
+    */
+
+    let api_path = await Util.api_path(req.parent.path, kernel)
+    let current_env = await Environment.get(api_path)
+    let default_env = await Environment.get(kernel.homedir)
+    current_env = Object.assign(process.env, default_env, current_env)
+
+    // if the key at current_env.PINOKIO_SHARE_VAR (by default it's 'url') is the variable being set, trigger the share logic
+    if (current_env.PINOKIO_SHARE_VAR && current_env.PINOKIO_SHARE_VAR in req.params) {
+      // the share logic is triggered ONLY IF the env.PINOKIO_SHARE is non-empty and contains "cloudflare", "local", or "cloudflare,local"
+      const KEY = current_env.PINOKIO_SHARE_VAR
+      if ("PINOKIO_SHARE_CLOUDFLARE" in current_env) {
+        let val = current_env.PINOKIO_SHARE_CLOUDFLARE.trim().toLowerCase()
+        if (val === "true" || val === "1") {
+          const c = new Cloudflare()
+          req.params.uri = req.params[KEY]
+          await c.tunnel(req, ondata, kernel)
+        }
+      }
+      if ("PINOKIO_SHARE_LOCAL" in current_env) {
+        let val = current_env.PINOKIO_SHARE_LOCAL.trim().toLowerCase()
+        if (val === "true" || val === "1") {
+          const p = new Proxy()
+          req.params.name = "Local Sharing",
+          req.params.uri = req.params[KEY]
+          await p.start(req, ondata, kernel)
+        }
+      }
+    }
+
     return res
   }
   async rm(req, ondata, kernel) {

package/kernel/api/proxy/index.js

@@ -1,3 +1,5 @@
+const { yellow, green, blue  } = require('kleur');
+const QRCode = require('qrcode');
 class P {
   async start (req, ondata, kernel) {
     /*
@@ -16,14 +18,26 @@ class P {
       // if exists, don't do anything
     } catch (e) {
       ondata({
-        raw: `\r\n[Start proxy] ${req.params.name} ${req.params.uri}\r\n`
+        raw: `\r\n[Start Local Sharing]\r\n`
       })
       let { name, uri, ...o } = req.params
       console.log("proxy.start", { name, uri, o })
       let response = await kernel.api.startProxy(req.parent.path, req.params.uri, req.params.name, o)
 
+      ondata({ raw: yellow("\r\n## [LOCAL NETWORK SHARING] Scan the QR code to open in any device\r\n\r\n") })
       ondata({
-        raw: `Proxy Started ${JSON.stringify(response)}\r\n`
+        raw: `${blue(response.proxy)}\r\n\r\n`
+      })
+      await new Promise((resolve, reject) => {
+        QRCode.toString(response.proxy, {
+          type: "terminal"
+        }, function(err, data) {
+          ondata({ raw: green(data.replaceAll("\n", "\r\n")) })
+          ondata({ raw: "\r\n" })
+          setTimeout(() => {
+            resolve()
+          }, 2000)
+        });
       })
 
       return response

package/kernel/api/shell/index.js

@@ -37,6 +37,10 @@ class Shell {
       req.params.cols = req.client.cols
     }
 
+    if (req.params) {
+      req.params.$parent = req.parent
+    }
+
 //    // create a persistent session
 //    req.params.persistent = true
 
@@ -85,6 +89,9 @@ class Shell {
     if (!req.params.id) {
       req.params.id = req.cwd 
     }
+    if (req.params) {
+      req.params.$parent = req.parent
+    }
 
     console.log("#### shell.enter", req.params)
 
@@ -111,6 +118,9 @@ class Shell {
         }
       }
     */
+    if (req.params) {
+      req.params.$parent = req.parent
+    }
     let options = {}
     if (req.cwd) options.cwd = req.cwd
     if (req.parent && req.parent.path) options.group = req.parent.path

package/kernel/environment.js

@@ -0,0 +1,138 @@
+const path = require('path')
+const fs = require('fs')
+const util = require('./util')
+const ENVS = [{
+  type: "cache_folder",
+  key: "HF_HOME",
+}, {
+  type: "cache_folder",
+  key: "TORCH_HOME",
+}, {
+  type: "cache_folder",
+  key: "HOMEBREW_CACHE",
+}, {
+  type: "cache_folder",
+  key: "XDG_CACHE_HOME",
+}, {
+  type: "cache_folder",
+  key: "PIP_CACHE_DIR",
+}, {
+  type: "cache_folder",
+  key: "PIP_TMPDIR",
+}, {
+  type: "cache_folder",
+  key: "TMPDIR",
+}, {
+  type: "cache_folder",
+  key: "TEMP",
+}, {
+  type: "cache_folder",
+  key: "TMP",
+}, {
+  type: "cache_folder",
+  key: "XDG_DATA_HOME",
+}, {
+  type: "cache_folder",
+  key: "XDG_CONFIG_HOME",
+}, {
+  type: "cache_folder",
+  key: "XDG_STATE_HOME",
+}, {
+  type: "cache_folder",
+  key: "GRADIO_TEMP_DIR",
+}, {
+  key: "PIP_CONFIG_FILE",
+  val: (home) => {
+    return path.resolve(home, "pipconfig")
+  }
+}, {
+  key: "CONDARC",
+  val: (home) => {
+    return path.resolve(home, "condarc")
+  },
+}, {
+  key: "PS1",
+  val: (home) => {
+    return "<<PINOKIO SHELL>> "
+  },
+}, {
+  key: "PINOKIO_SHARE_VAR",
+  val: (home) => {
+    return "url"
+  },
+}, {
+  type: "folder",
+  key: "PINOKIO_DRIVE",
+  val: (home) => {
+    return path.resolve(home, "drive")
+  }
+}];
+const folders = ENVS.filter((env) => {
+  return env.type === "cache_folder" || env.type === "folder"
+}).map((e) => {
+  return e.key
+})
+const ENV = (homedir) => {
+  const lines = ENVS.map((e) => {
+    if (e.type) {
+      if (e.type === "cache_folder") {
+        return `${e.key}=${path.resolve(homedir, "cache", e.key)}`
+      }
+    } else {
+      if (e.val) {
+        return `${e.key}=${e.val(homedir)}`
+      }
+    }
+  })
+  return lines.join("\n")
+}
+const APP_ENV = () => {
+  const items = [
+    "####################################################################",
+    "# GRADIO_TEMP_DIR",
+    "# All files uploaded through gradio goes here.",
+    "# Delete or comment this line",
+    "GRADIO_TEMP_DIR=cache/GRADIO_TEMP_DIR",
+    "",
+    "####################################################################",
+    "# PINOKIO_SHARE_LOCAL",
+    "# Set this variable to true to share the app on the local network.",
+    "PINOKIO_SHARE_LOCAL=true",
+    "",
+    "####################################################################",
+    "# PINOKIO_SHARE_CLOUDFLARE",
+    "# Set this variable to share the app publicly via cloudflare tunnel.",
+    "PINOKIO_SHARE_CLOUDFLARE=false",
+  ]
+  return items.join("\n")
+}
+const init_folders = async (homedir) => {
+  // get the environment object from homedir
+  const current_env = await get(homedir)
+
+  // filter out only the folder keys
+
+  // create folders
+  for(let key in current_env) {
+    // env key included in folders
+    if (folders.includes(key)) {
+      // mkdir
+      let full_path = path.resolve(homedir, current_env[key])
+      await fs.promises.mkdir(full_path, { recursive: true }).catch((e) => {})
+    }
+  }
+}
+
+const get = async (homedir) => {
+  const env_path = path.resolve(homedir, "ENVIRONMENT")
+  const current_env = await util.parse_env(env_path)
+  // if the key is a folder/cache_folder type, resolve the path
+  for(let key in current_env) {
+    if (folders.includes(key)) {
+      let full_path = path.resolve(homedir, current_env[key])
+      current_env[key] = full_path
+    }
+  }
+  return current_env
+}
+module.exports = { ENV, get, init_folders, APP_ENV }

package/kernel/index.js

@@ -7,7 +7,6 @@ const fastq = require('fastq')
 const fetch = require('cross-fetch');
 const waitOn = require('wait-on');
 const system = require('systeminformation');
-//const hostile = require('hostile');
 const Sysinfo = require('./sysinfo')
 const portfinder = require('portfinder');
 const Loader = require("./loader")
@@ -19,6 +18,8 @@ const Template = require('jimini')
 const Shells = require("./shells")
 const Key = require("./key")
 const Script = require('./script')
+const Environment = require("./environment")
+const Util = require('./util')
 const Config = require("./pinokio.json")
 const VARS = {
   pip: {
@@ -30,7 +31,7 @@ const VARS = {
 //const memwatch = require('@airbnb/node-memwatch');
 class Kernel {
   //schema = ">=1.0.0"
-  schema = "<=1.6.0"
+  schema = "<=1.7.0"
   constructor(store) {
     this.fetch = fetch
     this.store = store
@@ -40,6 +41,7 @@ class Kernel {
     this.key = new Key()
     this.jsdom = jsdom
     this.exposed = {}
+    this.envs = {}
   }
   resumeprocess(uri) {
     let proc = this.procs[uri]
@@ -99,7 +101,6 @@ class Kernel {
     return portfinder.getPortPromise()
   }
   path(...args) {
-    console.log("ARGS", args)
     return path.resolve(this.homedir, ...args)
   }
   exists(...args) {
@@ -173,7 +174,8 @@ class Kernel {
     await waitOn(options)
   }
 
-  async init() {
+  async init(options) {
+    this.port = options.port
     let home = this.store.get("home")
 
     // reset shells if they exist
@@ -237,30 +239,32 @@ class Kernel {
     }
     this.procs = {}
     this.template = new Template()
-
-
-
     try {
       if (this.homedir) {
+
+        // 0. create homedir
         await fs.promises.mkdir(this.homedir, { recursive: true }).catch((e) => {})
-        const cache_folders = [
-          "HF_HOME",
-          "TORCH_HOME",
-          "HOMEBREW_CACHE",
-          "XDG_CACHE_HOME",
-          "PIP_CACHE_DIR",
-          "PIP_TMPDIR",
-          "TMPDIR",
-          "TEMP",
-          "TMP",
-          "XDG_DATA_HOME",
-          "XDG_CONFIG_HOME",
-          "XDG_STATE_HOME",
-          "GRADIO_TEMP_DIR"
-        ]
-        for(let folder of cache_folders) {
-          await fs.promises.mkdir(path.resolve(this.homedir, "cache", folder), { recursive: true }).catch((e) => {})
+
+        // 1. check if ENVIRONMENT exists
+        // if it doesn't exist, write to ~/pinokio/ENVIRONMENT
+        let e = await this.exists(this.homedir, "ENVIRONMENT")
+        if (!e) {
+          let str = Environment.ENV(this.homedir)
+          await fs.promises.writeFile(path.resolve(this.homedir, "ENVIRONMENT"), str)
         }
+        // 2. mkdir all the folders if not already created
+        await Environment.init_folders(this.homedir)
+
+
+//        // 3. check if Caddyfile exists
+//        let e2 = await this.exists(this.homedir, "Caddyfile")
+//        if (!e2) {
+//          let str = `pinokio.local {
+//  reverse_proxy localhost:${this.port}
+//}`
+//          await fs.promises.writeFile(path.resolve(this.homedir, "Caddyfile"), str)
+//        }
+
 
       }
 
@@ -301,34 +305,16 @@ class Kernel {
 //        userDataDir: this.bin.path("puppet")
 //      });
 
-
-      // set hosts
-      //hostile.get(false, async (err, lines) => {
-      //  if (err) {
-      //    console.error(err.message)
-      //  }
-      //  let hostSet
-      //  for(let line of lines) {
-      //    if (line.includes("pinokio.network")) {
-      //      hostSet = true 
-      //    }
-      //  }
-      //  console.log({ hostSet })
-      //  if (!hostSet) {
-      //    console.log("setting hosts")
-      //    await this.exec({
-      //      sudo: true,
-      //      message: "npx hostile set 127.0.0.1 pinokio.network"
-      //    }, (e) => {
-      //      console.log(e)
-      //    })
-      //    console.log("success")
-      //  }
-      //})
-
     } catch (e) {
       console.log("### ERROR", e)
     }
+
+//    await this.exec({
+//      message: "caddy run",
+//      path: this.homedir
+//    }, (e) => {
+//      process.stdout.write(e.raw)
+//    })
   }
   async update_sysinfo() {
     try {

package/kernel/shell.js

@@ -12,6 +12,8 @@ const path = require("path")
 const sudo = require("sudo-prompt-programfiles-x86");
 const unparse = require('yargs-unparser-custom-flag');
 const shellPath = require('shell-path');
+const util = require('./util')
+const Environment = require('./environment')
 const home = os.homedir()
 class Shell {
   /*
@@ -111,25 +113,8 @@ class Shell {
     this.env.CMAKE_OBJECT_PATH_MAX = 1024
 
     // Well Known Cache
-    this.env.HF_HOME = path.resolve(this.kernel.homedir, "cache", "HF_HOME")
-    this.env.TORCH_HOME = path.resolve(this.kernel.homedir, "cache", "TORCH_HOME")
-    this.env.HOMEBREW_CACHE = path.resolve(this.kernel.homedir, "cache", "TORCH_HOME")
-    this.env.XDG_CACHE_HOME = path.resolve(this.kernel.homedir, "cache", "XDG_CACHE_HOME")
-    this.env.PIP_CACHE_DIR = path.resolve(this.kernel.homedir, "cache", "PIP_CACHE_DIR")
-    this.env.PIP_TMPDIR = path.resolve(this.kernel.homedir, "cache", "PIP_TMPDIR")
-    this.env.TMPDIR = path.resolve(this.kernel.homedir, "cache", "TMPDIR")
-    this.env.TEMP = path.resolve(this.kernel.homedir, "cache", "TEMP")
-    this.env.TMP = path.resolve(this.kernel.homedir, "cache", "TMP")
-    this.env.XDG_DATA_HOME = path.resolve(this.kernel.homedir, "cache", "XDG_DATA_HOME")
-    this.env.XDG_CONFIG_HOME = path.resolve(this.kernel.homedir, "cache", "XDG_CONFIG_HOME")
-    this.env.XDG_STATE_HOME = path.resolve(this.kernel.homedir, "cache", "XDG_STATE_HOME")
-    this.env.GRADIO_TEMP_DIR = path.resolve(this.kernel.homedir, "cache", "GRADIO_TEMP_DIR")
-    this.env.PIP_CONFIG_FILE = path.resolve(this.kernel.homedir, "pipconfig")
-    this.env.CONDARC = path.resolve(this.kernel.homedir, "condarc")
-
-    this.env.PS1 = "<<PINOKIO SHELL>> "
-//    this.env.PROMPT_COMMAND = "export PS1=\"<<PINOKIO SHELL>> \""
-
+    let home_env = await Environment.get(this.kernel.homedir)
+    this.env = Object.assign(this.env, home_env)
     let PATH_KEY;
     if (this.env.Path) {
       PATH_KEY = "Path"
@@ -149,32 +134,6 @@ class Shell {
 
     this.env[PATH_KEY] = this.env[PATH_KEY] + path.delimiter + path.resolve(this.kernel.homedir, 'bin')
 
-    // custom env was passed in
-
-    // override cache folders if cache is specified
-    if (params.cache) {
-      // cache data files
-      let cache_path = path.resolve(params.path, params.cache)
-      let types = [
-        "HF_HOME",                // huggingface models
-        "TORCH_HOME",             // torch hub models
-        "GRADIO_TEMP_DIR"         // gradio data
-//        "XDG_CACHE_HOME",
-//        "PIP_CACHE_DIR",
-//        "TMPDIR",
-//        "TEMP",
-//        "TMP",
-//        "XDG_DATA_HOME",
-//        "XDG_CONFIG_HOME",
-//        "XDG_STATE_HOME",
-      ]
-      for(let type of types) {
-        let p = path.resolve(cache_path, type)
-        this.env[type] = p
-        await fs.promises.mkdir(p, { recursive: true }).catch((e) => { })
-      }
-    }
-
 
     if (params.env) {
       for(let key in params.env) {
@@ -226,7 +185,6 @@ class Shell {
         delete this.env[key]
       }
     }
-
     // 3. path => path can be http, relative, absolute
     this.path = params.path
 

package/kernel/util.js

@@ -0,0 +1,22 @@
+const fs = require('fs')
+const path = require('path')
+const dotenv = require('dotenv')
+const parse_env = async (filename) => {
+  try {
+    const buf = await fs.promises.readFile(filename)
+    const config = dotenv.parse(buf) // will return an object
+    return config
+  } catch (e) {
+    return {}
+  }
+}
+const api_path = async (fullpath, kernel) => {
+  let api_path = `${kernel.homedir}${path.sep}api`
+  let rel_path = path.relative(api_path, fullpath)
+  let api_name = rel_path.split(path.sep)[0]
+  let current_api_path = `${api_path}${path.sep}${api_name}`
+  return current_api_path
+}
+module.exports = {
+  parse_env, api_path
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "1.3.40",
+  "version": "1.3.41",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -19,6 +19,7 @@
     "cross-fetch": "^3.1.5",
     "csv-parse": "^5.3.10",
     "decompress": "^4.2.1",
+    "dotenv": "^16.4.5",
     "ejs": "^3.1.9",
     "express": "^4.18.2",
     "express-http-proxy-cp": "^2.0.3",

package/server/index.js

@@ -34,6 +34,7 @@ const ejs = require('ejs');
 const Socket = require('./socket')
 const Kernel = require("../kernel")
 const packagejson = require("../package.json")
+const Environment = require("../kernel/environment")
 class Server {
   constructor(config) {
     this.tabs = {}
@@ -326,6 +327,14 @@ class Server {
 //      }
 //    }
 
+    if (path.basename(filepath) === "ENVIRONMENT") {
+      // if environment.json doesn't exist, 
+      let exists = await this.exists(filepath)
+      if (!exists) {
+        let content = await Environment.APP_ENV()
+        await fs.promises.writeFile(filepath, content)
+      }
+    }
 
     let stat = await fs.promises.stat(filepath)
     if (pathComponents.length === 0 && req.query.mode === "explore") {
@@ -353,7 +362,7 @@ class Server {
         name: "zip",
       }, {
         type: "conda",
-        name: ["nodejs", "ffmpeg"],
+        name: ["nodejs", "ffmpeg", ],
         args: "-c conda-forge"
       }]
       let platform = os.platform()
@@ -397,8 +406,6 @@ class Server {
         }
       }
 
-      console.log({ type: 1, requirements })
-
       let error = null
       try {
         this.compatible()
@@ -458,7 +465,6 @@ class Server {
         ...folders
       })
     } else if (stat.isFile()) {
-
       if (req.query && req.query.raw) {
         try {
 //          res.setHeader('Content-Disposition', 'inline');
@@ -518,7 +524,12 @@ class Server {
 
       let rawpath = `/raw/${pathComponents.join('/')}` + "?frame=true"
       if (editmode) {
-        let content = await fs.promises.readFile(filepath, "utf8")
+        let content
+        try {
+          content = await fs.promises.readFile(filepath, "utf8")
+        } catch (e) {
+          content = ""
+        }
 
         /********************************************************************
         *
@@ -621,7 +632,7 @@ class Server {
           name: "zip",
         }, {
           type: "conda",
-          name: ["nodejs", "ffmpeg"],
+          name: ["nodejs", "ffmpeg", ],
           args: "-c conda-forge"
         }]
         let platform = os.platform()
@@ -756,8 +767,6 @@ class Server {
           return r.relevant
         })
 
-        console.log({ type: 2, requirements })
-
 
         let mem = this.getMemory(filepath)
 //        let localMem = this.kernel.memory.local[filepath]
@@ -1214,8 +1223,14 @@ class Server {
 
 
   async renderMenu(uri, name, config, pathComponents) {
-    console.log("config.menu =" ,config.menu)
     if (config.menu) {
+
+      config.menu = [{
+        text: "Configure",
+        href: "ENVIRONMENT?mode=source",
+        icon: "fa-solid fa-gear"
+      }].concat(config.menu)
+
       for(let i=0; i<config.menu.length; i++) {
         let menuitem = config.menu[i]
 
@@ -1370,31 +1385,34 @@ class Server {
         return item.btn
       })
 
-        
-      
 
-      // get all proxies that belong to this repository
-      let childProxies = []
-      for(let scriptPath in this.kernel.api.proxies) {
-        let proxies = this.kernel.api.proxies[scriptPath]
-        for(let proxy of proxies) {
-          if (scriptPath.startsWith(this.kernel.path("api", name))) {
-            childProxies.push(proxy) 
-          }
-        }
-      }
 
-      let proxyMenu = []
-      for(let proxy of childProxies) {
-        proxyMenu.push({
-          btn: `<i class="fa-solid fa-wifi"></i> <strong>WiFi</strong>&nbsp;-&nbsp;${proxy.name}`,
-          target: "_blank",
-          href: proxy.proxy
-        })
-      }
-      config.menu = proxyMenu.concat(config.menu)
+      console.log("MENU", config.menu)
+        
+      
 
-      console.log("MENU", JSON.stringify(config.menu, null, 2))
+//      // get all proxies that belong to this repository
+//      let childProxies = []
+//      for(let scriptPath in this.kernel.api.proxies) {
+//        let proxies = this.kernel.api.proxies[scriptPath]
+//        for(let proxy of proxies) {
+//          if (scriptPath.startsWith(this.kernel.path("api", name))) {
+//            childProxies.push(proxy) 
+//          }
+//        }
+//      }
+//
+//      let proxyMenu = []
+//      for(let proxy of childProxies) {
+//        proxyMenu.push({
+//          btn: `<i class="fa-solid fa-wifi"></i> <strong>WiFi</strong>&nbsp;-&nbsp;${proxy.name}`,
+//          target: "_blank",
+//          href: proxy.proxy
+//        })
+//      }
+//      config.menu = proxyMenu.concat(config.menu)
+//
+//      console.log("MENU", JSON.stringify(config.menu, null, 2))
 
 
       return config
@@ -1798,7 +1816,7 @@ class Server {
     await this.syncConfig()
 
     // initialize kernel
-    await this.kernel.init()
+    await this.kernel.init({ port: this.port})
 
     // start proxy for Pinokio itself
     await this.kernel.api.startProxy("/", `http://127.0.0.1:${this.port}`, "/")

package/server/views/editor.ejs

@@ -129,6 +129,7 @@ document.addEventListener("DOMContentLoaded", async () => {
       maxLines: Infinity, // set to a large number
       minLines: 1 // set to a small number
     });
+    console.log("location.pathname", location.pathname)
     <% if (mod) { %>
       <% if (js) { %>
         editor.session.setMode("ace/mode/javascript");
@@ -136,6 +137,9 @@ document.addEventListener("DOMContentLoaded", async () => {
         editor.session.setMode("ace/mode/json");
       <% } %>
     <% } %>
+    if (location.pathname.endsWith("ENVIRONMENT")) {
+      editor.session.setMode("ace/mode/python");
+    }
     //editor.session.setMode("ace/mode/javascript");
     //editor.setValue(file)
     editor.clearSelection()
@@ -191,14 +195,17 @@ document.addEventListener("DOMContentLoaded", async () => {
       this.socket.run({
         method: "kernel.api.stop",
         params: {
-          uri: "<%=execUrl%>",
+          //uri: "<%=execUrl%>",
+          uri: "~" + location.pathname
         }
       }, (stream) => {
       })
     }
     save() {
       return new Promise((resolve, reject) => {
-        let cwd = "<%=execUrl%>"
+        //let cwd = "<%=execUrl%>"
+        let cwd = "~" + location.pathname
+        debugger
         this.socket.close()
         this.socket.run({
           method: "fs.write",
@@ -226,7 +233,8 @@ document.addEventListener("DOMContentLoaded", async () => {
         this.socket.run({
           //uri: location.pathname.slice(1).replace("api/", ""),
           //uri: "~" + location.pathname,
-          uri: "<%=execUrl%>",
+          //uri: "<%=execUrl%>",
+          uri: "~" + location.pathname,
           mode,
           input: query,
           client: {
@@ -689,15 +697,17 @@ document.addEventListener("DOMContentLoaded", async () => {
 //      await reloadMemory()
 //    }
 //  })
-  document.querySelector("#lv").addEventListener("click", (e) => {
-    let m = e.target.closest(".memory")
-    m.classList.toggle("collapsed")
-    if (m.classList.contains("collapsed")) {
-      m.querySelector("i").className = "fa-solid fa-sort-down"
-    } else {
-      m.querySelector("i").className = "fa-solid fa-sort-up"
-    }
-  })
+  if (document.querySelector("#lv")) {
+    document.querySelector("#lv").addEventListener("click", (e) => {
+      let m = e.target.closest(".memory")
+      m.classList.toggle("collapsed")
+      if (m.classList.contains("collapsed")) {
+        m.querySelector("i").className = "fa-solid fa-sort-down"
+      } else {
+        m.querySelector("i").className = "fa-solid fa-sort-up"
+      }
+    })
+  }
 })
 const reloadMemory = async () => {
   let url = "/pinokio/memory?filepath=" + encodeURI("<%-filepath%>")