pinokiod 5.1.10 → 5.1.11

package/kernel/api/fs/download_worker.js

@@ -0,0 +1,158 @@
+const fs = require('fs')
+const { DownloaderHelper } = require('node-downloader-helper')
+const randomUseragent = require('random-useragent')
+
+const safeSend = (msg) => {
+  try {
+    if (process.send) {
+      process.send(msg)
+    }
+  } catch (_) {
+    // ignore IPC errors
+  }
+}
+
+process.on('message', async (config) => {
+  const { url, folder, fileName, stallMs } = config || {}
+
+  if (!url || !folder) {
+    safeSend({
+      type: 'error',
+      error: { message: 'download_worker: invalid config (url/folder required)', stack: '' }
+    })
+    process.exit(1)
+    return
+  }
+
+  try {
+    await fs.promises.mkdir(folder, { recursive: true }).catch(() => {})
+  } catch (_) {
+    // if mkdir fails, DownloaderHelper will surface an error later
+  }
+
+  const userAgent = randomUseragent.getRandom((ua) => ua.browserName === 'Chrome') ||
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120 Safari/537.36'
+
+  const options = {
+    headers: {
+      'user-agent': userAgent
+    },
+    override: {
+      skip: true,
+      skipSmaller: false
+    },
+    resumeIfFileExists: true,
+    removeOnStop: false,
+    removeOnFail: false,
+    retry: { maxRetries: 10, delay: 5000 }
+  }
+
+  if (fileName) {
+    options.fileName = fileName
+  }
+
+  const dl = new DownloaderHelper(url, folder, options)
+
+  const STALL_MS = typeof stallMs === 'number' ? stallMs : 60000
+  let lastProgressAt = Date.now()
+  let finished = false
+  let stallTimer = setInterval(() => {
+    if (finished) return
+    const elapsed = Date.now() - lastProgressAt
+    if (elapsed > STALL_MS) {
+      safeSend({
+        type: 'stall',
+        elapsed
+      })
+      try {
+        dl.stop()
+      } catch (_) {
+      }
+    }
+  }, STALL_MS)
+
+  const cleanup = () => {
+    finished = true
+    if (stallTimer) {
+      clearInterval(stallTimer)
+      stallTimer = null
+    }
+  }
+
+  dl.on('download', (downloadInfo) => {
+    safeSend({ type: 'download', info: downloadInfo })
+  })
+
+  // High-frequency progress updates stay in the worker to drive the stall watchdog,
+  // but we only forward throttled updates to the parent to avoid flooding IPC.
+  dl.on('progress', (stats) => {
+    lastProgressAt = Date.now()
+  })
+
+  dl.on('progress.throttled', (stats) => {
+    lastProgressAt = Date.now()
+    safeSend({ type: 'progress.throttled', stats })
+  })
+
+  dl.on('stateChanged', (state) => {
+    safeSend({ type: 'stateChanged', state })
+  })
+
+  dl.on('redirected', (newUrl, oldUrl) => {
+    safeSend({ type: 'redirected', newUrl, oldUrl })
+  })
+
+  dl.on('resume', (isResumed) => {
+    safeSend({ type: 'resume', isResumed })
+  })
+
+  dl.on('timeout', () => {
+    safeSend({ type: 'timeout' })
+  })
+
+  dl.on('warning', (err) => {
+    safeSend({
+      type: 'warning',
+      error: {
+        message: err && err.message ? err.message : String(err),
+        stack: err && err.stack ? err.stack : ''
+      }
+    })
+  })
+
+  dl.on('skip', (skipInfo) => {
+    cleanup()
+    safeSend({ type: 'skip', info: skipInfo })
+    process.exit(0)
+  })
+
+  dl.on('end', (downloadInfo) => {
+    cleanup()
+    safeSend({ type: 'end', info: downloadInfo })
+    process.exit(0)
+  })
+
+  dl.on('error', (err) => {
+    cleanup()
+    safeSend({
+      type: 'error',
+      error: {
+        message: err && err.message ? err.message : String(err),
+        stack: err && err.stack ? err.stack : String(err)
+      }
+    })
+    process.exit(1)
+  })
+
+  dl.start().catch((err) => {
+    cleanup()
+    safeSend({
+      type: 'error',
+      error: {
+        message: err && err.message ? err.message : String(err),
+        stack: err && err.stack ? err.stack : String(err)
+      }
+    })
+    process.exit(1)
+  })
+})

package/kernel/api/fs/index.js

@@ -4,11 +4,10 @@ const fs = require("fs")
 const fse = require('fs-extra')
 const { rimraf } = require('rimraf')
 const Pdrive = require('pdrive')
-const { DownloaderHelper } = require('node-downloader-helper');
-const randomUseragent = require('random-useragent');
 const symlinkDir = require('symlink-dir')
 const retry = require('async-retry');
 const { createHash } = require('crypto');
+const { fork } = require('child_process')
 const Environment = require("../../environment")
 const Util = require("../../util")
 
@@ -559,108 +558,113 @@ class FS {
         path: <the eact file path to store the file under>
       }
     */
-    let params = req.params
-    let url = params.url || params.uri
-    let dl
-    let folder
-    let userAgent = randomUseragent.getRandom((ua) => {
-      return ua.browserName === 'Chrome';
-    });
+    const params = req.params || {}
+    const url = params.url || params.uri
+    if (!url) {
+      throw new Error('fs.download: url or uri is required')
+    }
 
+    let folder
+    let filename
     if (params.dir) {
       folder = kernel.api.filePath(params.dir, req.cwd)
-      await fs.promises.mkdir(folder, { recursive: true }).catch((e) => { })
-      dl = new DownloaderHelper(url, folder, {
-        headers: {
-          "user-agent": userAgent,
-        },
-//        httpsRequestOptions: {
-//          rejectUnauthorized: false
-//        },
-        override: {
-          skip: true,
-          skipSmaller: false,
-        },
-        resumeIfFileExists: true,
-        removeOnStop: false,
-        removeOnFail: false,
-        retry: { maxRetries: 10, delay: 5000 },
-      })
     } else if (params.path) {
-      let filepath = kernel.api.filePath(params.path, req.cwd)
+      const filepath = kernel.api.filePath(params.path, req.cwd)
       folder = path.dirname(filepath)
-      await fs.promises.mkdir(folder, { recursive: true }).catch((e) => { })
-      let filename = path.basename(filepath)
-      dl = new DownloaderHelper(url, folder, {
-        headers: {
-          "user-agent": userAgent,
-        },
-//        httpsRequestOptions: {
-//          rejectUnauthorized: false
-//        },
-        override: {
-          skip: true,
-          skipSmaller: false,
-        },
-        fileName: filename,
-        resumeIfFileExists: true,
-        removeOnStop: false,
-        removeOnFail: false,
-        retry: { maxRetries: 10, delay: 5000 },
-      })
+      filename = path.basename(filepath)
+    } else {
+      throw new Error('fs.download: either dir or path must be specified')
     }
+
     ondata({ raw: `\r\nDownloading ${url} to ${folder}...\r\n` })
-    let res = await new Promise((resolve, reject) => {
-      dl.on('end', () => {
-        console.log('Download Completed');
-        ondata({ raw: `\r\nDownload Complete!\r\n` })
-        resolve()
-      })
-      dl.on('error', (err) => {
-        console.log('Download Error', err)
-        ondata({ raw: `\r\n[Download Error] ${err.stack}!\r\n` })
-        reject(err)
-      })
-      dl.on('progress', (stats) => {
-        let p = Math.floor(stats.progress)
-        let str = ""
-        for(let i=0; i<p; i++) {
-          str += "#"
-        }
-        for(let i=p; i<100; i++) {
-          str += "-"
+
+    const workerPath = path.resolve(__dirname, 'download_worker.js')
+    await fs.promises.mkdir(folder, { recursive: true }).catch(() => {})
+
+    await new Promise((resolve, reject) => {
+      let settled = false
+      const finish = (err) => {
+        if (settled) return
+        settled = true
+        if (err) {
+          reject(err)
+        } else {
+          resolve()
         }
-        ondata({ raw: `\r${str}` })
-      })
-      dl.on('download', (downloadInfo) => {
-        const msg = `\r\n[Download Started] ${JSON.stringify({ name: downloadInfo.fileName, total: downloadInfo.totalSize })}\r\n`
-        ondata({ raw: msg })
-      })
-      dl.on('skip', (skipInfo) => {
-        const msg = `\r\n[Download Skipped] File already exists: ${JSON.stringify(skipInfo)}\r\n`
-        ondata({ raw: msg })
-        resolve()
+      }
+
+      const child = fork(workerPath, [], {
+        stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
       })
-      dl.on('retry', (attempt, opts, err) => {
-        const msg = "\r\n[Retrying] " + JSON.stringify({
-          RetryAttempt: `${attempt}/${opts.maxRetries}`,
-          StartsOn: `${opts.delay / 1000} secs`,
-          Reason: err ? err.message : 'unknown'
-        }) + "\r\n";
-        ondata({ raw: msg })
+
+      child.on('message', (msg) => {
+        if (!msg || typeof msg !== 'object') return
+        switch (msg.type) {
+          case 'download': {
+            const payload = msg.info || {}
+            // Minimal start message; no extra JSON noise.
+            ondata({ raw: `\r\n[Download Started] ${payload.fileName || ''}\r\n` })
+            break
+          }
+          case 'progress.throttled': {
+            const stats = msg.stats || {}
+            const p = typeof stats.progress === 'number' ? Math.floor(stats.progress) : null
+            if (p !== null && p >= 0 && p <= 100) {
+              let bar = ''
+              for (let i = 0; i < p; i++) bar += '#'
+              for (let i = p; i < 100; i++) bar += '-'
+              ondata({ raw: `\r${bar}` })
+            }
+            break
+          }
+          case 'stall': {
+            const elapsed = msg.elapsed || 0
+            ondata({ raw: `\r\n[Download Watchdog] No progress for ${(elapsed / 1000).toFixed(1)}s (url: ${url})\r\n` })
+            break
+          }
+          case 'skip': {
+            const info = msg.info || {}
+            ondata({ raw: `\r\n[Download Skipped] File already exists: ${JSON.stringify(info)}\r\n` })
+            finish()
+            break
+          }
+          case 'end': {
+            const info = msg.info || {}
+            ondata({ raw: `\r\n[Download End] ${JSON.stringify(info)}\r\n` })
+            ondata({ raw: `\r\nDownload Complete!\r\n` })
+            finish()
+            break
+          }
+          case 'error': {
+            const err = msg.error || {}
+            const text = err.stack || err.message || String(err)
+            ondata({ raw: `\r\n[Download Error] ${text}\r\n` })
+            finish(new Error(err.message || 'download error'))
+            break
+          }
+          default:
+            break
+        }
       })
-      dl.on('stateChanged', (state) => {
-        const msg = "\r\n[State changed] " + state + "\r\n"
-        ondata({ raw: msg })
+
+      child.on('exit', (code) => {
+        if (settled) return
+        if (code === 0) {
+          finish()
+        } else {
+          finish(new Error(`download worker exited with code ${code}`))
+        }
       })
-      dl.on('redirected', (newUrl, oldUrl) => {
-        const msg = `\r\n[Redirected] '${oldUrl}' => '${newUrl}'\r\n`
-        ondata({ raw: msg })
+
+      child.on('error', (err) => {
+        if (settled) return
+        finish(err)
       })
 
-      dl.start().catch((err) => {
-        ondata({ raw: `\r\n[Download Failed] ${err.stack}!\r\n` })
-        reject(err)
+      child.send({
+        url,
+        folder,
+        fileName: filename || null
       })
     })
   }

package/kernel/api/index.js

@@ -787,6 +787,9 @@ class Api {
 
   }
   async step (request, rawrpc, input, i, total, args) {
+    if (this.kernel.sysReady) {
+      await this.kernel.sysReady
+    }
     await Promise.all([this.init(), this.kernel.update_sysinfo()])
 
     // clear global regular expression object RegExp.lastMatch (memory leak prevention)

package/kernel/bin/index.js

@@ -1023,6 +1023,10 @@ class Bin {
     return relevant.platform && relevant.arch && relevant.gpu
   }
   async check(config) {
+    if (typeof this.kernel.binCheckDepth !== 'number') {
+      this.kernel.binCheckDepth = 0
+    }
+    this.kernel.binCheckDepth++
     let requirements = this.requirements(config)
     let requirements_pending = !this.installed_initialized
     let install_required = true
@@ -1087,7 +1091,7 @@ class Bin {
     requirements = requirements.filter((r) => {
       return r.relevant
     })
-
+    this.kernel.binCheckDepth--
     return {
       error,
       title: config.bin.title,
@@ -1097,7 +1101,6 @@ class Bin {
       install_required,
       requirements_pending
     }
-
   }
   winBuildNumber() {
     let osVersion = (/(\d+)\.(\d+)\.(\d+)/g).exec(os.release());

package/kernel/environment.js

@@ -587,12 +587,29 @@ const init = async (options, kernel) => {
         await fs.promises.writeFile(destination, rendered_recipe)
       }
     }
-    await fs.promises.writeFile(path.resolve(root, ".geminiignore"), `ENVIRONMENT
+    const geminiIgnorePath = path.resolve(root, ".geminiignore")
+    const geminiIgnoreContent = `ENVIRONMENT
 !/logs
 !/GEMINI.md
 !/SPEC.md
 !/app
-!${kernel.homedir}`)
+!${kernel.homedir}`
+    let shouldWriteGeminiIgnore = false
+    try {
+      const existingGeminiIgnore = await fs.promises.readFile(geminiIgnorePath, "utf8")
+      if (existingGeminiIgnore !== geminiIgnoreContent) {
+        shouldWriteGeminiIgnore = true
+      }
+    } catch (error) {
+      if (error && error.code === "ENOENT") {
+        shouldWriteGeminiIgnore = true
+      } else {
+        throw error
+      }
+    }
+    if (shouldWriteGeminiIgnore) {
+      await fs.promises.writeFile(geminiIgnorePath, geminiIgnoreContent)
+    }
   }
 
   const gitDir = path.resolve(root, ".git")