pinokiod 1.3.72 → 1.3.74

package/kernel/api/cloudflare/index.js

@@ -12,7 +12,6 @@ class C {
 
       => cloudflared tunnel --url http://localhost:8080
     */
-    console.log("TUNNEL", req)
     const message = `cloudflared tunnel --url ${req.params.uri}`
     let params = {
       id: message,
@@ -26,7 +25,6 @@ class C {
     if (req.cwd) options.cwd = req.cwd
     if (req.parent && req.parent.path) options.group = req.parent.path
     let pattern = /(https:.+?trycloudflare\.com)/
-    console.log("params", params)
     let cloudflare_url = await new Promise((resolve, reject) => {
       kernel.shell.start(params, options, (e) => {
         ondata(e)
@@ -52,6 +50,15 @@ class C {
       });
     })
 
+    /***************************************************
+      Expose local variabl
+
+      local.$share := {
+        cloudflare: {
+          <original_url>: <cloudflare_url>
+        }
+      }
+    ***************************************************/
     if (!kernel.memory.local[req.parent.path].$share) {
       kernel.memory.local[req.parent.path].$share = {}
     }

package/kernel/api/env/index.js

@@ -1,3 +1,4 @@
+const path = require('path')
 const set = require("../set")
 const rm = require("../rm")
 const Environment = require('../../environment')
@@ -14,9 +15,53 @@ class Env {
       }
     */
     // write to current app folder's ENVIRONMENT
+    let api_path = Util.api_path(req.parent.path, kernel)
+    let env_path = path.resolve(api_path, "ENVIRONMENT")
+    await Util.update_env(env_path, req.params)
+  }
+  async switch(req, ondata, kernel) {
+    /*
+      req := {
+        "method": "env.switch",
+        "params": {
+          <key>: ["true", "false"],
+        }
+      }
+
+      req := {
+        "method": "env.switch",
+        "params": {
+          <key>: ["apple", "orange", "grape"],
+        }
+      }
+    */
+    let api_path = Util.api_path(req.parent.path, kernel)
+    let env_path = path.resolve(api_path, "ENVIRONMENT")
+    let env = await Environment.get2(req.parent.path, kernel)
+    // does the key exist?
 
-    let api_path = await Util.api_path(req.parent.path, kernel)
-    await Util.update_env(api_path, req.params)
+    let update = {}
+    for(let key in req.params) {
+      let options = req.params[key]
+      if (key in env) {
+        // if the key exists, check if the values are one of the options
+        let existing_val = env[key]
+        if (options.includes(existing_val)) {
+          // find the item index
+          let existing_index = options.indexOf(existing_val)
+          // choose the next option in the array
+          let next_index = (existing_index + 1) % options.length
+          let next_item = options[next_index]
+          update[key] = next_item
+        } else {
+          // if not one of the options, ignore. must match exactly
+        }
+      } else {
+        // if the key doesn't exist, the first item is the default
+        update[key] = options[0]
+      }
+    }
+    await Util.update_env(env_path, update)
   }
 }
 module.exports = Env

package/kernel/api/fs/index.js

@@ -131,7 +131,7 @@ class FS {
 
     // start with the proces.env => merge pinokio global ENVIRONMENT => merge app ENVIRONMENT
     let default_env = await Environment.get(kernel.homedir)
-    let api_path = await Util.api_path(req.parent.path, kernel)
+    let api_path = Util.api_path(req.parent.path, kernel)
     let api_env = await Environment.get(api_path)
     let current_env = Object.assign(process.env, default_env, api_env)
 

package/kernel/api/index.js

@@ -9,6 +9,7 @@ const Lproxy = require('lproxy')
 const { glob, sync, hasMagic } = require('glob-gitignore')
 const fastq = require('fastq')
 const Loader = require("../loader")
+const Environment = require("../environment")
 
 class Api {
   constructor(kernel) {
@@ -534,6 +535,10 @@ class Api {
 
     this.state = memory
     this.executing = request
+    // get fully resolved env
+    let env = await Environment.get2(request.path, this.kernel)
+    // set template
+    this.kernel.template.update(env)
 
     // render until `{{ }}` pattern does not exist
     // 1. render once

package/kernel/api/local/index.js

@@ -63,7 +63,7 @@ class Local {
       }
     */
 
-    let api_path = await Util.api_path(req.parent.path, kernel)
+    let api_path = 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)

package/kernel/api/proxy/index.js

@@ -40,6 +40,15 @@ class P {
         });
       })
 
+      /***************************************************
+        Expose local variabl
+
+        local.$share := {
+          local: {
+            <original_url>: <cloudflare_url>
+          }
+        }
+      ***************************************************/
       if (!kernel.memory.local[req.parent.path].$share) {
         kernel.memory.local[req.parent.path].$share = {}
       }

package/kernel/environment.js

@@ -1,103 +1,157 @@
 const path = require('path')
 const fs = require('fs')
-const util = require('./util')
+const Util = require('./util')
 const ENVS = [{
-  type: "cache_folder",
-  key: "HF_HOME",
-}, {
-  type: "cache_folder",
-  key: "TORCH_HOME",
-}, {
-  type: "cache_folder",
+  type: ["system"],
   key: "HOMEBREW_CACHE",
+  hidden: true,
+  val: "./cache/HOMEBREW_CACHE"
 }, {
-  type: "cache_folder",
+  type: ["system"],
   key: "XDG_CACHE_HOME",
+  hidden: true,
+  val: "./cache/XDG_CACHE_HOME"
 }, {
-  type: "cache_folder",
+  type: ["system"],
   key: "PIP_CACHE_DIR",
+  hidden: true,
+  val: "./cache/PIP_CACHE_DIR"
 }, {
-  type: "cache_folder",
+  type: ["system"],
   key: "PIP_TMPDIR",
+  hidden: true,
+  val: "./cache/PIP_TMPDIR"
 }, {
-  type: "cache_folder",
+  type: ["system"],
   key: "TMPDIR",
+  hidden: true,
+  val: "./cache/TMPDIR"
 }, {
-  type: "cache_folder",
+  type: ["system"],
   key: "TEMP",
+  hidden: true,
+  val: "./cache/TEMP"
 }, {
-  type: "cache_folder",
+  type: ["system"],
   key: "TMP",
+  hidden: true,
+  val: "./cache/TMP"
 }, {
-  type: "cache_folder",
+  type: ["system"],
   key: "XDG_DATA_HOME",
+  hidden: true,
+  val: "./cache/XDG_DATA_HOME"
 }, {
-  type: "cache_folder",
+  type: ["system"],
   key: "XDG_CONFIG_HOME",
+  hidden: true,
+  val: "./cache/XDG_CONFIG_HOME"
 }, {
-  type: "cache_folder",
+  type: ["system"],
   key: "XDG_STATE_HOME",
+  hidden: true,
+  val: "./cache/XDG_STATE_HOME"
 }, {
-  type: "cache_folder",
-  key: "GRADIO_TEMP_DIR",
-}, {
+  type: ["system"],
   key: "PIP_CONFIG_FILE",
-  val: (home) => {
-    return path.resolve(home, "pipconfig")
-  }
+  hidden: true,
+  val: "./pipconfig"
 }, {
+  type: ["system"],
   key: "CONDARC",
-  val: (home) => {
-    return path.resolve(home, "condarc")
-  },
+  hidden: true,
+  val: "./condarc"
 }, {
+  type: ["system"],
   key: "PS1",
-  val: (home) => {
-    return "<<PINOKIO SHELL>> "
-  },
+  hidden: true,
+  val: "<<PINOKIO SHELL>> "
+}, {
+  type: ["system"],
+  key: "GRADIO_ANALYTICS_ENABLED",
+  val: "False"
 }, {
+  type: ["system"],
+  key: "GRADIO_ALLOWED_PATHS",
+  val: "./",
+  comment: [
+    "##########################################################################",
+    "#",
+    "# GRADIO_ALLOWED_PATHS",
+    "#",
+    "# This allows every Gradio app installed under Pinokio to serve files",
+    "# outside of each app's root folder, which is useful for many cases.",
+    "# Do not touch this unless you want to add additional paths",
+    "#",
+    "##########################################################################",
+  ],
+}, {
+  type: ["system"],
   key: "PINOKIO_SHARE_VAR",
-  val: (home) => {
-    return "url"
-  },
+  val: "url",
+  comment: [
+    "##########################################################################",
+    "#",
+    "# PINOKIO_SHARE_VAR",
+    "#",
+    "# When you set this local variable from any script, it will trigger Pinokio",
+    "# share actions (local sharing, cloudflare, ...)",
+    "#",
+    "# You can customize whether to avoid this using PINOKIO_SHARE_CLOUDFLARE",
+    "# and PINOKIO_SHARE_LOCAL",
+    "#",
+    "##########################################################################",
+  ],
 }, {
-  type: "folder",
+  type: ["system"],
   key: "PINOKIO_DRIVE",
-  val: (home) => {
-    return path.resolve(home, "drive")
-  }
-}, {
-  key: "PINOKIO_SCRIPT_DEFAULT",
-  val: (home) => {
-    return "true"
-  }
+  val: "./drive",
+  comment: [
+    "##########################################################################",
+    "#",
+    "# PINOKIO_DRIVE",
+    "#",
+    "# The virtual drive path.",
+    "# Change it if you want to use a different path.",
+    "# You can even enter an absolute path to use a folder outside of pinokio",
+    "# or an entirely different disk drive",
+    "#",
+    "##########################################################################",
+  ],
 }, {
+  type: ["system"],
   key: "PINOKIO_PORT",
-  val: (home) => {
-    return "80"
-  }
-}];
-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 = [
+  val: "80",
+  comment: [
+    "##########################################################################",
+    "#",
+    "# PINOKIO_PORT",
+    "#",
+    "# The server port Pinokio will use. By default it's 80 but you can",
+    "# Change it to anything else",
+    "#",
+    "##########################################################################",
+  ],
+}, {
+  type: ["system", "app"],
+  key: "GRADIO_TEMP_DIR",
+  val: "./cache/GRADIO_TEMP_DIR",
+  comment: [
+    "##########################################################################",
+    "#",
+    "# GRADIO_TEMP_DIR",
+    "# All the files uploaded through gradio goes here.",
+    "#",
+    "# Delete this line to store the files under PINOKIO_HOME/cache/GRADIO_TEMPDIR",
+    "# or change the path if you want to use a different path",
+    "#",
+    "##########################################################################",
+  ],
+}, {
+  type: ["system", "app"],
+  key: "HF_HOME",
+  val: "./cache/HF_HOME",
+  comment: [
     "##########################################################################",
     "#",
     "# HF_HOME",
@@ -110,8 +164,12 @@ const APP_ENV = () => {
     "# huggingface files under PINOKIO_HOME/cache/HF_HOME without redundancy.",
     "#",
     "##########################################################################",
-    "HF_HOME=cache/HF_HOME",
-    "",
+  ],
+}, {
+  type: ["system", "app"],
+  key: "TORCH_HOME",
+  val: "./cache/TORCH_HOME",
+  comment: [
     "##########################################################################",
     "#",
     "# TORCH_HOME",
@@ -123,35 +181,36 @@ const APP_ENV = () => {
     "# torch hub files under PINOKIO_HOME/cache/TORCH_HOME without redundancy.",
     "#",
     "##########################################################################",
-    "TORCH_HOME=cache/TORCH_HOME",
-    "",
-    "##########################################################################",
-    "#",
-    "# GRADIO_TEMP_DIR",
-    "# All the files uploaded through gradio goes here.",
-    "#",
-    "# Delete this line to store the files under PINOKIO_HOME/cache/GRADIO_TEMPDIR",
-    "# or change the path if you want to use a different path",
-    "#",
-    "##########################################################################",
-    "GRADIO_TEMP_DIR=cache/GRADIO_TEMP_DIR",
-    "",
+  ],
+}, {
+  type: ["system", "app"],
+  key: "PINOKIO_SHARE_LOCAL",
+  val: "false",
+  comment: [
     "##########################################################################",
     "#",
     "# PINOKIO_SHARE_LOCAL",
     "# Set this variable to true to share the app on the local network.",
     "#",
     "##########################################################################",
-    "PINOKIO_SHARE_LOCAL=true",
-    "",
+  ],
+}, {
+  type: ["system", "app"],
+  key: "PINOKIO_SHARE_CLOUDFLARE",
+  val: "false",
+  comment: [
     "##########################################################################",
     "#",
     "# PINOKIO_SHARE_CLOUDFLARE",
     "# Set this variable to share the app publicly via cloudflare tunnel.",
     "#",
     "##########################################################################",
-    "PINOKIO_SHARE_CLOUDFLARE=false",
-    "",
+  ]
+}, {
+  type: ["system", "app"],
+  key: "PINOKIO_SCRIPT_DEFAULT",
+  val: "true",
+  comment: [
     "##########################################################################",
     "#",
     "# PINOKIO_SCRIPT_DEFAULT",
@@ -159,36 +218,82 @@ const APP_ENV = () => {
     "# will NOT automatically run",
     "#",
     "##########################################################################",
-    "PINOKIO_SCRIPT_DEFAULT=true",
   ]
-  return items.join("\n")
+}];
+//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")
+//}
+
+// type := system|app
+const ENV = (type) => {
+  return ENVS.filter((e) => {
+    return e.type.includes(type)
+  }).map((e) => {
+    let comment = ""
+    if (e.comment && Array.isArray(e.comment)) {
+      comment = "\n" + e.comment.join("\n") + "\n"
+    }
+
+    let kv
+    if (typeof e.val === "function") {
+      kv = `${e.key}=${e.val(type)}`
+    } else {
+      kv = `${e.key}=${e.val}`
+    }
+    return comment + kv
+  }).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])
+    let val = current_env[key]
+
+    // skip condarc and pipconfig => special case
+    if (val === "./condarc" || val === "./pipconfig") {
+      continue
+    }
+    let is_absolute = path.isAbsolute(val)
+    let is_relative = val.startsWith("./")
+    if (is_absolute || is_relative) {
+      // it's a path
+      let full_path = path.resolve(homedir, val)
       await fs.promises.mkdir(full_path, { recursive: true }).catch((e) => {})
     }
   }
 }
+
+// Get the actual environment variable at specific path
+const get2 = async (filepath, kernel) => {
+  let api_path = Util.api_path(filepath, kernel)
+  let default_env = await get(kernel.homedir)
+  let api_env = await get(api_path)
+  let current_env = Object.assign(process.env, default_env, api_env)
+  return current_env
+}
 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
+  const current_env = await Util.parse_env(env_path)
   for(let key in current_env) {
-    if (folders.includes(key)) {
-      let full_path = path.resolve(homedir, current_env[key])
+    let val = current_env[key]
+    if (val.startsWith("./")) {
+      let full_path = path.resolve(homedir, val)
       current_env[key] = full_path
     }
+    if (val.trim() === "") {
+      delete current_env[key]
+    }
   }
   return current_env
 }
-module.exports = { ENV, get, init_folders, APP_ENV }
+module.exports = { ENV, get, get2, init_folders }

package/kernel/index.js

@@ -33,7 +33,7 @@ const VARS = {
 //const memwatch = require('@airbnb/node-memwatch');
 class Kernel {
   //schema = ">=1.0.0"
-  schema = "<=1.7.0"
+  schema = "<=2.0.0"
   constructor(store) {
     this.fetch = fetch
     this.store = store
@@ -57,11 +57,9 @@ class Kernel {
     } else {
       folderpath = this.homedir
     }
-    console.log({ args , folderpath,homedir: this.homedir })
-    let api_path = await Util.api_path(folderpath, this)
+    let api_path = Util.api_path(folderpath, this)
     let current_env = await Environment.get(api_path)
     let default_env = await Environment.get(this.homedir)
-    console.log({ api_path, current_env, default_env })
     return Object.assign(process.env, default_env, current_env)
   }
   resumeprocess(uri) {
@@ -269,7 +267,7 @@ class Kernel {
         // 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)
+          let str = Environment.ENV("system")
           await fs.promises.writeFile(path.resolve(this.homedir, "ENVIRONMENT"), str)
         }
         // 2. mkdir all the folders if not already created

package/kernel/shell.js

@@ -71,8 +71,6 @@ class Shell {
     this.cols = params.cols ? params.cols : 100;
     this.rows = params.rows ? params.rows : 30;
 
-    console.log({ cols: this.cols, rows: this.rows })
-
     this.vt = new Terminal({
       allowProposedApi: true,
       cols: this.cols,
@@ -121,7 +119,7 @@ class Shell {
     // if the shell is running from a script file, the params.$parent will include the path to the parent script
     // this means we need to apply app environment as well
     if (params.$parent) {
-      let api_path = await Util.api_path(params.$parent.path, this.kernel)
+      let api_path = Util.api_path(params.$parent.path, this.kernel)
 
       // initialize folders
       await Environment.init_folders(api_path)

package/kernel/util.js

@@ -67,7 +67,7 @@ const parse_env_detail = async (filename) => {
   */
   return items
 }
-const api_path = async (fullpath, kernel) => {
+const api_path = (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]
@@ -87,40 +87,37 @@ const escapeStringRegexp = (string) => {
 }
 
 const update_env = async (filepath, changes) => {
-  const envString = await fs.promises.readFile(filepath, "utf8")
-  console.log({ filepath, envString, changes })
-	let hasAppended = false;
-  console.log("changes", changes)
+  const env = await fs.promises.readFile(filepath, "utf8")
+  let append = false;
   const newval = Object.keys(changes).reduce((result, varname) => {
-		const value = changes[varname].toString()
-			.replace(breakPattern, breakReplacement)
-			.replace(returnPattern, returnReplacement)
-			.trim();
-		const safeName = escapeStringRegexp(varname);
-		const varPattern = new RegExp(`^(${h}*${safeName}${h}*=${h}*)\\S*(${h}*)$`, "gm");
-		if (varPattern.test(result)) {
-			const safeValue = value.replace(groupPattern, groupReplacement);
-			return result.replace(varPattern, `$1${safeValue}$2`);
-		} else if (result === "") {
-			hasAppended = true;
-			return `${varname}=${value}${EOL}`;
-		} else if (!result.endsWith(EOL) && !hasAppended) {
-			hasAppended = true;
-			// Add an extra break between previously defined and newly appended variable
-			return `${result}${EOL}${EOL}${varname}=${value}`;
-		} else if (!result.endsWith(EOL)) {
-			// Add break for appended variable
-			return `${result}${EOL}${varname}=${value}`;
-		} else if (result.endsWith(EOL) && !hasAppended) {
-			hasAppended = true;
-			// Add an extra break between previously defined and newly appended variable
-			return `${result}${EOL}${varname}=${value}${EOL}`;
-		} else /*if (result.endsWith(EOL))*/ {
-			// Add break for appended variable
-			return `${result}${varname}=${value}${EOL}`;
-		}
-	}, normalizeEOL(envString));
-  console.log("updated ENVIRONMENT", newval)
+    const value = changes[varname].toString()
+    .replace(breakPattern, breakReplacement)
+    .replace(returnPattern, returnReplacement)
+    .trim();
+    const safeName = escapeStringRegexp(varname);
+    const varPattern = new RegExp(`^(${h}*${safeName}${h}*=${h}*)\\S*(${h}*)$`, "gm");
+    if (varPattern.test(result)) {
+      const safeValue = value.replace(groupPattern, groupReplacement);
+      return result.replace(varPattern, `$1${safeValue}$2`);
+    } else if (result === "") {
+      append = true;
+      return `${varname}=${value}${EOL}`;
+    } else if (!result.endsWith(EOL) && !append) {
+      append = true;
+      // Add an extra break between previously defined and newly appended variable
+      return `${result}${EOL}${EOL}${varname}=${value}`;
+    } else if (!result.endsWith(EOL)) {
+      // Add break for appended variable
+      return `${result}${EOL}${varname}=${value}`;
+    } else if (result.endsWith(EOL) && !append) {
+      append = true;
+      // Add an extra break between previously defined and newly appended variable
+      return `${result}${EOL}${varname}=${value}${EOL}`;
+    } else {
+      // Add break for appended variable
+      return `${result}${varname}=${value}${EOL}`;
+    }
+  }, normalizeEOL(env));
   await fs.promises.writeFile(filepath, newval)
 };
 module.exports = {

package/package.json

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

package/server/index.js

@@ -229,26 +229,21 @@ class Server {
         }
       }
     }
-    console.log("M", mem)
 
     let current = this.kernel.path("api", name, "ENVIRONMENT")
       // if environment.json doesn't exist, 
     let exists = await this.exists(current)
-    console.log("exists", exists)
     if (!exists) {
-      let content = await Environment.APP_ENV()
-      console.log("write", content)
+      let content = await Environment.ENV("app")
       await fs.promises.writeFile(current, content)
     }
 
     let mode = "run"
-    console.log("req.query", req.query)
     if (req.query && req.query.mode) {
       mode = req.query.mode
     }
 
     const env = await this.kernel.env("api/" + name)
-    console.log("env", env)
 
     //res.render("browser", {
     res.render("browser-experimental", {
@@ -378,7 +373,7 @@ class Server {
       // if environment.json doesn't exist, 
       let exists = await this.exists(filepath)
       if (!exists) {
-        let content = await Environment.APP_ENV()
+        let content = await Environment.ENV("app")
         await fs.promises.writeFile(filepath, content)
       }
     }
@@ -902,7 +897,6 @@ class Server {
           execUrl: "~" + req.originalUrl.replace(/^\/_api/, "\/api"),
           proxies: this.kernel.api.proxies[filepath],
         }
-        console.log("result", result)
 
         res.render(template, result)
       } else {
@@ -1114,7 +1108,6 @@ class Server {
 
           // check if there is a running process with this folder name
           let runningApps = new Set()
-          console.log("running", this.kernel.api.running)
           for(let key in this.kernel.api.running) {
             let p = this.kernel.path("api", items[i].name) + path.sep
             //let re = new RegExp(items[i].name)
@@ -1172,11 +1165,6 @@ class Server {
         qr_cloudflare = await QRCode.toDataURL(this.cloudflare_pub)
       }
 
-
-
-      console.log("running", JSON.stringify(running, null, 2))
-
-
       res.render("index", {
         home_url: `http://localhost:${this.port}`,
         proxy: home_proxy,
@@ -1284,25 +1272,25 @@ class Server {
   async renderMenu(uri, name, config, pathComponents) {
     if (config.menu) {
 
-      config.menu = [{
-        base: "/",
-        text: "Configure",
-        href: `env/api/${name}/ENVIRONMENT`,
-        icon: "fa-solid fa-gear",
-        mode: "refresh"
-//      }, {
+//      config.menu = [{
 //        base: "/",
-//        text: "Public Share",
-//        action: {
-//          method: "env.set",
-//          params: {
-//            "PINOKIO_SHARE_CLOUDFLARE": true,
-//            "PINOKIO_SHARE_LOCAL": true
-//          }
-//        },
+//        text: "Configure",
 //        href: `env/api/${name}/ENVIRONMENT`,
-//        icon: "fa-solid fa-gear"
-      }].concat(config.menu)
+//        icon: "fa-solid fa-gear",
+//        mode: "refresh"
+////      }, {
+////        base: "/",
+////        text: "Public Share",
+////        action: {
+////          method: "env.set",
+////          params: {
+////            "PINOKIO_SHARE_CLOUDFLARE": true,
+////            "PINOKIO_SHARE_LOCAL": true
+////          }
+////        },
+////        href: `env/api/${name}/ENVIRONMENT`,
+////        icon: "fa-solid fa-gear"
+//      }].concat(config.menu)
 
       for(let i=0; i<config.menu.length; i++) {
         let menuitem = config.menu[i]
@@ -1464,7 +1452,6 @@ class Server {
 
 
 
-      console.log("MENU", config.menu)
         
       
 
@@ -1899,7 +1886,7 @@ class Server {
     if (this.kernel.homedir) {
       let ex = await this.kernel.exists(this.kernel.homedir, "ENVIRONMENT")
       if (!ex) {
-        let str = Environment.ENV(this.kernel.homedir)
+        let str = Environment.ENV("system")
         await fs.promises.writeFile(path.resolve(this.homedir, "ENVIRONMENT"), str)
       }
 

package/server/socket.js

@@ -115,7 +115,6 @@ class Socket {
               raw: res.data.raw
             }
           }
-          console.log("*** res1", res)
           subscriber.send(JSON.stringify(res))
         }
       });
@@ -144,7 +143,6 @@ class Socket {
                 raw: res.data.raw
               }
             }
-            console.log("*** res2", res)
             subscriber.send(JSON.stringify(res))
 
           }

package/server/views/browser-experimental.ejs

@@ -554,6 +554,9 @@ body.dark .loader-container {
     <a target="/share/<%=name%>" href="/share/<%=name%>", class="btn header-item frame-link" data-index="1" data-mode="refresh">
       <div class='tab'><i class="fa-solid fa-wifi"></i> Share</div>
     </a>
+    <a target="/env/api/<%=name%>/ENVIRONMENT" href="/env/api/<%=name%>/ENVIRONMENT", class="btn header-item frame-link" data-index="1" data-mode="refresh">
+      <div class='tab'><i class="fa-solid fa-gear"></i> Configure</div>
+    </a>
   </div>
   <div class='m h menu' data-type='h'>
     <% if (config.menu) { %>

package/server/views/explore.ejs

@@ -147,9 +147,9 @@ body main iframe {
 </header>
 <main>
 <% if (theme === "dark") { %>
-  <iframe name="<%=schema%>" src="https://pinokio.computer/dark" no-referrer></iframe>
+  <iframe name="<%=schema%>" src="https://pinokio.computer/dark" <%=agent === "electron" ? "no-referrer" : ""%>></iframe>
 <% } else { %>
-  <iframe name="<%=schema%>" src="https://pinokio.computer/app" no-referrer></iframe>
+  <iframe name="<%=schema%>" src="https://pinokio.computer/app" <%=agent === "electron" ? "no-referrer" : ""%>></iframe>
 <% } %>
 </main>
 <link href="/xterm.min.css" rel="stylesheet" />

package/server/views/fullscreen_editor.ejs

@@ -190,7 +190,6 @@ document.addEventListener("DOMContentLoaded", async () => {
       return new Promise(async (resolve, reject) => {
 //        await this.save()
         await this.socket.close()
-        console.log({ cols: this.term.cols, rows: this.term.rows })
 
         let query = Object.fromEntries(new URLSearchParams(location.search))
 
@@ -205,11 +204,6 @@ document.addEventListener("DOMContentLoaded", async () => {
             rows: this.term.rows,
           }
         }, async (packet) => {
-          
-          console.log("packet", packet.type, packet)
-          if (packet.data) {
-            console.log("packet.data.raw", packet.data.raw)
-          }
           if (packet.type === 'start') {
             refreshParent(packet)
             reloadMemory()
@@ -241,7 +235,6 @@ document.addEventListener("DOMContentLoaded", async () => {
 //              </div>`
             }
           } else if (packet.type === "stream") {
-            console.log({ cols: this.term.cols, rows: this.term.rows })
             if (packet.data.raw) {
               this.write(packet.data.raw)
             } else if (packet.data.json) {
@@ -257,7 +250,7 @@ document.addEventListener("DOMContentLoaded", async () => {
           } else if (packet.type === 'disconnect') {
             refreshParent(packet)
             reloadMemory()
-            //this.term.write("\r\nDisconnected...\r\n")
+            this.term.write("\r\nDisconnected...\r\n")
             document.querySelector("footer").innerHTML = "<b>Ready</b>"
             this.socket.close()
             document.querySelector(".run .play").classList.remove("hidden")