pinokiod 3.85.0 → 3.87.0

package/Dockerfile

@@ -0,0 +1,61 @@
+# Production image for pinokiod with required system tooling
+FROM node:20 AS build
+WORKDIR /app
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends python3 make g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY package*.json ./
+RUN npm ci --omit=dev && npm cache clean --force
+
+FROM node:20 AS runtime
+ENV NODE_ENV=production
+WORKDIR /app
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        bluez \
+        curl \
+        git \
+        lsof \
+        net-tools \
+        openssh-client \
+        p7zip-full \
+        pv \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=build /app/node_modules ./node_modules
+COPY . .
+
+# Pre-seed the Pinokio dev preset into the image as a compressed archive
+RUN mkdir -p /app/.pinokio-seed \
+    && PINOKIO_HOME=/app/.pinokio-seed PINOKIO_SETUP_MODE=prod_dev node script/install-mode.js \
+    && rm -rf /app/.pinokio-seed/network \
+    && mkdir -p /app/.pinokio-seed/network \
+    && git clone --depth 1 https://github.com/pinokiocomputer/network /app/.pinokio-seed/network/system \
+    && 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 \
+    && rm -rf /app/.pinokio-seed/prototype/system/.git \
+    && curl -fsSL https://raw.githubusercontent.com/pinokiocomputer/home/refs/heads/main/docs/README.md -o /app/.pinokio-seed/prototype/PINOKIO.md \
+    && curl -fsSL https://raw.githubusercontent.com/pinokiocomputer/pterm/refs/heads/main/README.md -o /app/.pinokio-seed/prototype/PTERM.md \
+    && tar -C /app/.pinokio-seed -czf /app/.pinokio-seed.tgz . \
+    && rm -rf /app/.pinokio-seed
+
+COPY docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
+
+ENV PINOKIO_HOME=/data/pinokio \
+    PINOKIO_HTTPS_ACTIVE=1 \
+    PINOKIO_NETWORK_ACTIVE=1
+VOLUME ["/data/pinokio"]
+
+EXPOSE 8080
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
+CMD ["npm", "start"]

package/docker-entrypoint.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [ -z "${PINOKIO_STDOUT_STREAMED:-}" ] && command -v stdbuf >/dev/null 2>&1; then
+  export PINOKIO_STDOUT_STREAMED=1
+  exec 1> >(stdbuf -oL cat)
+  exec 2> >(stdbuf -oL cat >&2)
+fi
+
+PINOKIO_HOME="${PINOKIO_HOME:-/data/pinokio}"
+export PINOKIO_HOME
+
+if [ ! -d "$PINOKIO_HOME/bin" ]; then
+  mkdir -p "$PINOKIO_HOME"
+  if [ -f "/app/.pinokio-seed.tgz" ]; then
+    echo "[entrypoint] Bootstrapping Pinokio home at $PINOKIO_HOME"
+    echo "[entrypoint] Extracting Pinokio seed archive (this may take a moment)"
+    if command -v pv >/dev/null 2>&1; then
+      step=${PINOKIO_PROGRESS_STEP:-5}
+      interval=${PINOKIO_PROGRESS_INTERVAL:-1}
+      progress_fifo_raw=$(mktemp -t pinokio-progress-raw.XXXXXX)
+      progress_fifo=$(mktemp -t pinokio-progress.XXXXXX)
+      rm -f "$progress_fifo_raw" "$progress_fifo"
+      mkfifo "$progress_fifo_raw" "$progress_fifo"
+      (
+        trap 'rm -f "$progress_fifo_raw" "$progress_fifo"; exit 0' EXIT INT TERM
+        tr '\r' '\n' <"$progress_fifo_raw" >"$progress_fifo"
+      ) &
+      progress_transform_pid=$!
+      (
+        last=-1
+        while IFS= read -r line; do
+          progress=$(printf '%s\n' "$line" | grep -oE '[0-9]+%' | tail -n 1 || true)
+          if [ -n "$progress" ]; then
+            pct=${progress%%%}
+            if [ "$pct" -gt "$last" ]; then
+              delta=$((pct - last))
+              if [ "$pct" -eq 100 ] || [ "$delta" -ge "$step" ] || [ "$last" -lt 0 ]; then
+                last=$pct
+                printf '[entrypoint] Extracting: %d%%\n' "$pct"
+              fi
+            fi
+          fi
+        done <"$progress_fifo"
+        if [ "$last" -lt 100 ]; then
+          printf '[entrypoint] Extracting: 100%%\n'
+        fi
+      ) &
+      progress_reader_pid=$!
+      pv -f -i "$interval" /app/.pinokio-seed.tgz 2>"$progress_fifo_raw" | tar -C "$PINOKIO_HOME" -xz -f -
+      status=$?
+      wait "$progress_reader_pid" || true
+      wait "$progress_transform_pid" || true
+      rm -f "$progress_fifo_raw" "$progress_fifo"
+      if [ $status -ne 0 ]; then
+        exit $status
+      fi
+    else
+      tar -C "$PINOKIO_HOME" -xzf /app/.pinokio-seed.tgz
+    fi
+    echo "[entrypoint] Seed archive extraction complete"
+  elif [ -d "/app/.pinokio-seed" ]; then
+    echo "[entrypoint] Bootstrapping Pinokio home at $PINOKIO_HOME"
+    echo "[entrypoint] Copying Pinokio seed directory"
+    cp -a /app/.pinokio-seed/. "$PINOKIO_HOME"/
+    echo "[entrypoint] Seed directory copy complete"
+  fi
+fi
+
+if [ -e "/app/.pinokio-seed" ] && [ ! -L "/app/.pinokio-seed" ]; then
+  rm -rf /app/.pinokio-seed
+fi
+ln -sfn "$PINOKIO_HOME" /app/.pinokio-seed
+
+exec "$@"

package/kernel/api/hf/index.js

@@ -26,7 +26,7 @@ class HF {
     delete params.path
     let chunks = unparse(params)
     let message = [
-      `huggingface-cli download ${chunks.join(" ")}` + (kernel.platform === "win32" ? " && dir" : " ; ls")
+      `hf download ${chunks.join(" ")}` + (kernel.platform === "win32" ? " && dir" : " ; ls")
     ]
     console.log({ message, before: req.params.message })
     req.params.message = message

package/kernel/api/index.js

@@ -802,6 +802,13 @@ class Api {
       current: i,
       uri: request.uri,
       cwd,
+      exists: (...args) => {
+        return fs.existsSync(path.resolve(cwd, ...args))
+      },
+      running: (...args) => {
+        let fullpath = path.resolve(cwd, ...args)
+        return this.running[fullpath]
+      },
       name,
       self: script,
       port,
@@ -1324,7 +1331,7 @@ class Api {
     */
 
     // concurrency
-    let concurrency = (rawrpc.queue ? 1 : 10);
+    let concurrency = (rawrpc.queue ? 1 : 1000);
 
     // queue_id
 

package/kernel/api/shell/index.js

@@ -53,6 +53,9 @@ class Shell {
     } else if (req.parent && req.parent.path) {
       options.group = req.parent.path
     }
+    if (req.parent && req.parent.body && req.parent.body.title) {
+      options.title = req.parent.body.title
+    }
     let id = await kernel.shell.start(req.params, options, ondata)
     return id
     //let id = await kernel.shell.start(req.params, options)
@@ -130,6 +133,9 @@ class Shell {
     } else if (req.parent && req.parent.path) {
       options.group = req.parent.path
     }
+    if (req.parent && req.parent.body && req.parent.body.title) {
+      options.title = req.parent.body.title
+    }
     if (req.client) {
       req.params.rows = req.client.rows
       req.params.cols = req.client.cols

package/kernel/api/terminal/index.js

@@ -0,0 +1,166 @@
+const fs = require('fs')
+const path = require('path')
+const sanitize = require('sanitize-filename')
+
+class Terminal {
+  async upload(req, ondata, kernel) {
+    const params = req.params || {}
+    const files = Array.isArray(params.files) ? params.files : []
+    const buffers = params.buffers || {}
+
+    if (files.length === 0) {
+      if (ondata) {
+        ondata({ raw: "\r\nNo files provided for upload.\r\n" })
+      }
+      return { files: [] }
+    }
+
+    const shellInstance = this.resolveShellInstance(params, kernel)
+    const shellCwd = this.resolveShellCwd(params, kernel)
+    const baseCwd = shellInstance && typeof shellInstance.path === 'string' && shellInstance.path.trim().length > 0
+      ? shellInstance.path
+      : shellCwd
+
+    const uploadRoot = baseCwd
+      ? path.join(baseCwd, '.pinokio-temp')
+      : kernel.path('temp', 'web-terminal')
+
+    await fs.promises.mkdir(uploadRoot, { recursive: true })
+
+    const saved = []
+
+    for (const file of files) {
+      const key = file && file.key
+      if (!key || !buffers[key]) {
+        continue
+      }
+      const sourceBuffer = buffers[key]
+      const originalName = typeof file.name === 'string' && file.name.length > 0
+        ? file.name
+        : 'upload'
+      const sanitized = sanitize(originalName) || `upload-${Date.now()}`
+      const targetName = await this.uniqueFilename(uploadRoot, sanitized)
+      const targetPath = path.join(uploadRoot, targetName)
+
+      await fs.promises.writeFile(targetPath, sourceBuffer)
+      delete buffers[key]
+
+      const homeRelativePath = path.relative(kernel.homedir, targetPath)
+      const normalizedHomeRelativePath = homeRelativePath.split(path.sep).join('/')
+      const cliPath = targetPath
+      const cliBase = baseCwd || kernel.homedir
+      const cliRelative = cliBase ? path.relative(cliBase, targetPath) : null
+      const cliRelativePath = cliRelative ? cliRelative.split(path.sep).join('/') : null
+
+      saved.push({
+        originalName,
+        storedAs: targetName,
+        path: targetPath,
+        size: typeof file.size === 'number' ? file.size : sourceBuffer.length,
+        mimeType: typeof file.type === 'string' ? file.type : '',
+        homeRelativePath: normalizedHomeRelativePath,
+        displayPath: `~/${normalizedHomeRelativePath}`,
+        cliPath,
+        cliRelativePath
+      })
+
+    }
+
+    if (saved.length === 0) {
+      if (ondata) {
+        ondata({ raw: "\r\nNo files were saved.\r\n" })
+      }
+      return { files: saved }
+    }
+
+    const marker = '[attachment] '
+    if (params && params.id && kernel && kernel.shell && typeof kernel.shell.emit === 'function') {
+      try {
+        kernel.shell.emit({
+          id: params.id,
+          emit: marker,
+          paste: true
+        })
+      } catch (error) {
+        if (ondata) {
+          ondata({ raw: marker })
+        }
+      }
+    } else if (ondata) {
+      ondata({ raw: marker })
+    }
+
+    // Break references to potentially large buffers once handled.
+    if (req.params) {
+      req.params.buffers = {}
+    }
+
+    return { files: saved }
+  }
+
+  resolveShellInstance(params, kernel) {
+    if (!params || typeof params.id !== 'string') {
+      return null
+    }
+    if (!kernel || !kernel.shell || typeof kernel.shell.get !== 'function') {
+      return null
+    }
+    try {
+      return kernel.shell.get(params.id)
+    } catch (error) {
+      return null
+    }
+  }
+
+  resolveShellCwd(params, kernel) {
+    if (!params || typeof params.cwd !== 'string') {
+      return null
+    }
+    let cwd = params.cwd.trim()
+    if (!cwd) {
+      return null
+    }
+    const queryIndex = cwd.indexOf('?')
+    if (queryIndex !== -1) {
+      cwd = cwd.slice(0, queryIndex)
+    }
+    const hashIndex = cwd.indexOf('#')
+    if (hashIndex !== -1) {
+      cwd = cwd.slice(0, hashIndex)
+    }
+    if (!cwd) {
+      return null
+    }
+    if (cwd.startsWith('~/')) {
+      return path.resolve(kernel.homedir, cwd.slice(2))
+    }
+    if (path.isAbsolute(cwd)) {
+      return cwd
+    }
+    return path.resolve(kernel.homedir, cwd)
+  }
+
+  async uniqueFilename(dir, candidate) {
+    const parsed = path.parse(candidate)
+    const baseName = parsed.name && parsed.name.trim().length > 0 ? parsed.name : 'upload'
+    const extension = parsed.ext || ''
+    let attemptIndex = 0
+
+    // Ensure we do not end up in an infinite loop if fs.access throws non-ENOENT errors.
+    while (true) {
+      const attemptName = attemptIndex === 0 ? `${baseName}${extension}` : `${baseName}_${attemptIndex}${extension}`
+      const attemptPath = path.join(dir, attemptName)
+      try {
+        await fs.promises.access(attemptPath)
+        attemptIndex += 1
+      } catch (error) {
+        if (error && error.code === 'ENOENT') {
+          return attemptName
+        }
+        throw error
+      }
+    }
+  }
+}
+
+module.exports = Terminal

package/kernel/bin/caddy.js

@@ -32,10 +32,16 @@ class Caddy {
       await new Promise((resolve, reject) => {
         let interval = setInterval(() => {
           if (this.kernel.processes.caddy_pid) {
-            console.log("kill caddy", this.kernel.processes.caddy_pid)
-            kill(this.kernel.processes.caddy_pid, "SIGKILL", true)
-            console.log("killed existing caddy")
-            resolve()
+            try {
+              console.log("kill caddy", this.kernel.processes.caddy_pid)
+              kill(this.kernel.processes.caddy_pid, "SIGKILL", true)
+              console.log("killed existing caddy")
+              clearInterval(interval)
+              resolve()
+            } catch (error) {
+              clearInterval(interval)
+              reject(error)
+            }
           } else {
             console.log("try killing existing caddy again in 1 sec")
           }

package/kernel/bin/conda.js

@@ -148,7 +148,8 @@ report_errors: false`)
             //if (String(version) === "24.7.0") {
             let channel = chunks[3]
             let coerced = semver.coerce(version)
-            let mamba_requirement = ">=24.11.1"
+            //let mamba_requirement = ">=24.11.1"
+            let mamba_requirement = ">=25.4.0"
             //if (semver.satisfies(coerced, mamba_requirement) && channel === "conda-forge") {
             if (semver.satisfies(coerced, mamba_requirement)) {
               conda_check.mamba = true
@@ -266,7 +267,7 @@ report_errors: false`)
     let cmds = [
       //"conda clean -y --index-cache",
       "conda clean -y --all",
-      `conda install -y -c conda-forge sqlite=3.47.2 ${mods}`,
+      `conda install -y -c conda-forge sqlite=3.47.2 conda-libmamba-solver>=25.4.0 ${mods}`,
 
 //      `conda config --file ${this.kernel.path('condarc')} --set remote_connect_timeout_secs 20`,
 //      `conda config --file ${this.kernel.path('condarc')} --set remote_read_timeout_secs 300`,

package/kernel/bin/index.js

@@ -368,7 +368,7 @@ class Bin {
               //if (String(version) === "24.7.0") {
               let channel = chunks[3]
               let coerced = semver.coerce(version)
-              let mamba_requirement = ">=24.11.1"
+              let mamba_requirement = ">=25.4.0"
               //if (semver.satisfies(coerced, mamba_requirement) && channel === "conda-forge") {
               if (semver.satisfies(coerced, mamba_requirement)) {
                 conda_check.mamba = true
@@ -631,6 +631,57 @@ class Bin {
       return res
     }
   }
+  async resolveInstallRequirements(req, ondata) {
+    let params = req.params
+    let mode = req.mode
+    if (typeof params === 'string') {
+      let trimmed = params.trim()
+      if (trimmed.length === 0) {
+        params = null
+      } else if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        try {
+          params = JSON.parse(trimmed)
+        } catch (e) {
+          params = trimmed
+        }
+      } else {
+        params = trimmed
+      }
+    }
+    if (Array.isArray(params)) {
+      return params
+    }
+    if (params && typeof params === 'object') {
+      if (Array.isArray(params.requirements)) {
+        return params.requirements
+      }
+      if (typeof params.mode === 'string' && params.mode.trim().length > 0) {
+        mode = params.mode.trim()
+      }
+    }
+    if (!mode && typeof params === 'string' && params.length > 0) {
+      mode = params
+    }
+    if (!mode && req.params && typeof req.params.mode === 'string' && req.params.mode.trim().length > 0) {
+      mode = req.params.mode.trim()
+    }
+    if (!mode && typeof req.mode === 'string' && req.mode.trim().length > 0) {
+      mode = req.mode.trim()
+    }
+    if (!mode) {
+      throw new Error('kernel.bin.install requires `requirements` array or `mode` string in params')
+    }
+    const preset = this.preset(mode)
+    if (!preset) {
+      const available = Object.keys(Setup).sort().join(', ')
+      throw new Error(`Unknown setup mode "${mode}". Available modes: ${available}`)
+    }
+    if (ondata) {
+      ondata({ html: `<b>Resolving setup preset "${mode}"</b>` }, 'notify2')
+    }
+    const { requirements } = await this.check({ bin: preset })
+    return Array.isArray(requirements) ? requirements : []
+  }
 //  async init_launcher(req, ondata) {
 //    console.log("init_launcher", req)
 //    try {
@@ -685,7 +736,7 @@ class Bin {
     } else {
       this.client = null
     }
-    let requirements = JSON.parse(req.params)
+    let requirements = await this.resolveInstallRequirements(req, ondata)
     for(let x=0; x<10; x++) {
       console.log(`## Install Attempt ${x}`)
       let i = 0;

package/kernel/bin/setup.js

@@ -111,6 +111,38 @@ module.exports = {
       ]
     }
   },
+  prod_dev: (kernel) => {
+    let requirements = [
+      { name: "conda", },
+      { name: "zip", },
+    ]
+    if (platform === "darwin") {
+      requirements.push({ name: "brew" })
+    }
+    requirements = requirements.concat([
+      { name: "git", },
+      { name: "node", },
+      { name: "cli", },
+      { name: "uv", },
+      { name: "caddy", },
+      { name: "py", },
+      { name: "browserless" },
+    ])
+    let conda_requirements = [
+      zip_cmd,
+      "uv",
+      "node",
+      "git",
+      "caddy"
+    ]
+    return {
+      icon: "fa-solid fa-laptop-code",
+      title: "Coding (Essential)",
+      description: "Install common modules required for development (Node.js, python, Visual Studio Developer Tools (Windows), Xcode build tools (Mac)",
+      requirements,
+      conda_requirements,
+    }
+  },
   dev: (kernel) => {
     let requirements = [
       { name: "conda", },

package/kernel/bin/vs.js

@@ -125,6 +125,15 @@ class VS {
 
   }
   async init() {
+    if (!this.kernel || this.kernel.platform !== "win32") {
+      this._env = {
+        MSVC_PATH: [],
+        BUILD_PATH: [],
+        CMAKE_PATH: [],
+        CL_PATH: [],
+      }
+      return
+    }
     if (this.kernel.platform === "win32") {
       /*
       {
@@ -151,12 +160,12 @@ class VS {
     }
   }
   env () {
-    if (this.kernel.platform === "win32") {
+    if (this.kernel && this.kernel.platform === "win32") {
       return this._env
     }
   }
   async installed() {
-    if (this.kernel.platform === "win32") {
+    if (this.kernel && this.kernel.platform === "win32") {
       await this.init()
       console.log("VS INSTALLED CHECK", this._env)
       return this._env.MSVC_PATH && this._env.MSVC_PATH.length > 0 && this._env.BUILD_PATH && this._env.BUILD_PATH.length > 0 && this._env.CMAKE_PATH && this._env.CMAKE_PATH.length > 0 && this._env.VCVARSALL_PATH && this._env.VCVARSALL_PATH.length > 0

package/kernel/index.js

@@ -33,6 +33,7 @@ const Store = require('./store')
 const Proto = require('./prototype')
 const Plugin = require('./plugin')
 const Router = require("./router")
+const PinokioDomainRouter = require("./router/pinokio_domain_router")
 const Procs = require('./procs')
 const Peer = require('./peer')
 const Git = require('./git')
@@ -388,11 +389,43 @@ class Kernel {
       return false
     }
   }
+  async resolvePinokioDomain() {
+    const envDomain = (process.env.PINOKIO_DOMAIN || '').trim()
+    if (envDomain.length > 0) {
+      return envDomain
+    }
+    if (!this.homedir) {
+      return ''
+    }
+    try {
+      const env = await Environment.get(this.homedir, this)
+      const value = (env.PINOKIO_DOMAIN || '').trim()
+      return value
+    } catch (e) {
+      return ''
+    }
+  }
+  async ensureRouterMode() {
+    const domain = await this.resolvePinokioDomain()
+    const shouldUseCustom = domain.length > 0
+    if (shouldUseCustom && this.router_kind !== 'custom-domain') {
+      console.log('[router] switching to custom-domain router mode')
+      this.router = new PinokioDomainRouter(this)
+      this.router_kind = 'custom-domain'
+    } else if (!shouldUseCustom && this.router_kind !== 'default') {
+      console.log('[router] switching to default router mode')
+      this.router = new Router(this)
+      this.router_kind = 'default'
+    }
+    this.pinokio_domain_value = domain
+  }
   async refresh(notify_peers) {
     const ts = Date.now()
 
     await this.peer.check(this)
 
+    await this.ensureRouterMode()
+
     if (this.peer.peer_active) {
       // 1. get the process list
       await this.processes.refresh()
@@ -769,7 +802,7 @@ class Kernel {
 ///  }
   async init(options) {
 
-    let home = this.store.get("home")
+    let home = this.store.get("home") || process.env.PINOKIO_HOME
 
     // reset shells if they exist
     if (this.shell) {
@@ -834,7 +867,14 @@ class Kernel {
     this.api = new Api(this)
     this.python = new Python(this)
     this.shell = new Shells(this)
-    this.router = new Router(this)
+    this.pinokio_domain_value = (process.env.PINOKIO_DOMAIN || '').trim()
+    if (this.pinokio_domain_value) {
+      this.router = new PinokioDomainRouter(this)
+      this.router_kind = 'custom-domain'
+    } else {
+      this.router = new Router(this)
+      this.router_kind = 'default'
+    }
     this.connect = new Connect(this)
     this.system = system
     this.keys = {}

package/kernel/info.js

@@ -68,6 +68,42 @@ class Info {
     let resolved_path = path.resolve(cwd, ...args)
     return this.kernel.memory.global[resolved_path] || {}
   }
+  scriptsByApi() {
+    if (!this.kernel || !this.kernel.memory || !this.kernel.memory.local) {
+      return {}
+    }
+
+    const apiRoot = this.kernel.path("api")
+    const scriptsByApi = {}
+
+    for (const [id, localVariables] of Object.entries(this.kernel.memory.local)) {
+      if (!id) continue
+
+      const scriptPath = id.split("?")[0]
+      if (!scriptPath || !this.isSubpath(apiRoot, scriptPath)) continue
+
+      const apiName = Util.api_name(scriptPath, this.kernel)
+      if (!apiName || apiName === '.' || apiName.startsWith('..')) continue
+
+      if (!scriptsByApi[apiName]) {
+        scriptsByApi[apiName] = []
+      }
+
+      scriptsByApi[apiName].push({
+        uri: scriptPath,
+        local: localVariables || {}
+      })
+    }
+
+    return scriptsByApi
+  }
+  isSubpath(parent, child) {
+    if (!parent || !child) {
+      return false
+    }
+    const relative = path.relative(parent, child)
+    return !!relative && !relative.startsWith('..') && !path.isAbsolute(relative)
+  }
 }
 
 module.exports = Info