pinokiod 7.4.0 → 7.4.2

package/kernel/index.js

@@ -43,6 +43,7 @@ const AppLauncher = require('./app_launcher')
 const ReadyState = require('./ready')
 const Autolaunch = require('./autolaunch')
 const LaunchRequirements = require('./launch_requirements')
+const LegacyCleanup = require('./legacy_cleanup')
 const { DownloaderHelper } = require('node-downloader-helper');
 const { ProxyAgent } = require('proxy-agent');
 const fakeUa = require('fake-useragent');
@@ -100,6 +101,7 @@ class Kernel {
     this.launchRequirements = new LaunchRequirements(this)
     this.autolaunch = new Autolaunch(this)
     this.autolaunch_status = this.autolaunch.startupStatus()
+    this.legacyCleanup = new LegacyCleanup(this)
     this.sysReady = new Promise((resolve) => {
       this._resolveSysReady = resolve
     })
@@ -1192,6 +1194,11 @@ class Kernel {
         await Environment.ensurePinokioCacheDirs(this, {
           throwOnFailure: true
         })
+        await this.legacyCleanup.runOnce((event) => {
+          if (event && typeof event.raw === "string") {
+            console.log(event.raw.trimEnd())
+          }
+        })
 
         // if key.json doesn't exist, create an empty json file
         let ee = await this.exists(this.homedir, "key.json")

package/kernel/legacy_cleanup/ffmpeg.js

@@ -0,0 +1,167 @@
+const fs = require('fs')
+const path = require('path')
+
+const LEGACY_FFMPEG_HOOK_NAMES = [
+  'zz_pinokio_ffmpeg.sh',
+  'zz_pinokio_ffmpeg.bat',
+  'zz_pinokio_ffmpeg.ps1',
+]
+
+const TRANSIENT_REMOVE_ERRORS = new Set([
+  'EBUSY',
+  'ENOTEMPTY',
+  'EPERM',
+  'EACCES',
+])
+
+const REMOVE_RETRY_COUNT = 5
+const REMOVE_RETRY_DELAY_MS = 100
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+async function pathExists(target) {
+  return fs.promises.access(target).then(() => true).catch(() => false)
+}
+
+function legacyFfmpegRuntimePaths(kernel) {
+  if (!kernel || !kernel.bin || typeof kernel.bin.path !== 'function') {
+    return []
+  }
+  return [
+    kernel.bin.path('ffmpeg-env'),
+    kernel.bin.path('ffmpeg-pkgs'),
+    kernel.bin.path('ffmpeg'),
+    kernel.bin.path('ffmpeg-tmp'),
+  ]
+}
+
+function legacyFfmpegHookFiles(kernel) {
+  if (!kernel || !kernel.bin || typeof kernel.bin.path !== 'function') {
+    return []
+  }
+  const dirs = [
+    kernel.bin.path('miniconda', 'etc', 'conda', 'activate.d'),
+    kernel.bin.path('miniconda', 'etc', 'conda', 'deactivate.d'),
+  ]
+  return dirs.flatMap((dir) => LEGACY_FFMPEG_HOOK_NAMES.map((name) => path.resolve(dir, name)))
+}
+
+function manualFfmpegHookCleanupMessage(failures) {
+  const files = failures.map((failure) => failure.target)
+  return [
+    'Pinokio could not remove old FFmpeg Conda activation hooks.',
+    '',
+    'These old hooks can break the base Conda environment by adding the removed ffmpeg-env runtime to PATH.',
+    '',
+    'Close all Pinokio windows and any terminals using Pinokio, then delete these files if they exist:',
+    ...files.map((file) => `- ${file}`),
+    '',
+    'After deleting them, reopen Pinokio.',
+  ].join('\n')
+}
+
+class LegacyFfmpegCleanupError extends Error {
+  constructor(failures) {
+    super(manualFfmpegHookCleanupMessage(failures))
+    this.name = 'LegacyFfmpegCleanupError'
+    this.failures = failures
+  }
+}
+
+async function hasAnyPath(paths) {
+  for (const target of paths) {
+    if (await pathExists(target)) {
+      return true
+    }
+  }
+  return false
+}
+
+async function hasCleanupTargets(kernel) {
+  return await hasAnyPath(legacyFfmpegHookFiles(kernel)) ||
+    await hasAnyPath(legacyFfmpegRuntimePaths(kernel))
+}
+
+function isTransientRemoveError(error) {
+  return error && TRANSIENT_REMOVE_ERRORS.has(error.code)
+}
+
+async function retryTransient(operation) {
+  let lastError
+  for (let attempt = 0; attempt <= REMOVE_RETRY_COUNT; attempt += 1) {
+    try {
+      return await operation()
+    } catch (error) {
+      if (error && error.code === 'ENOENT') {
+        return null
+      }
+      lastError = error
+      if (!isTransientRemoveError(error) || attempt === REMOVE_RETRY_COUNT) {
+        break
+      }
+      await delay(REMOVE_RETRY_DELAY_MS * (attempt + 1))
+    }
+  }
+  throw lastError
+}
+
+async function removeLegacyPath(target, ondata) {
+  const existed = await pathExists(target)
+  if (!existed) {
+    return { target, found: false, removed: false }
+  }
+
+  try {
+    await retryTransient(() => fs.promises.rm(target, {
+      recursive: true,
+      force: true,
+      maxRetries: REMOVE_RETRY_COUNT,
+      retryDelay: REMOVE_RETRY_DELAY_MS,
+    }))
+  } catch (error) {
+    if (ondata) {
+      const reason = error && (error.code || error.message) ? error.code || error.message : String(error)
+      ondata({ raw: `could not remove legacy path: ${target} (${reason})\r\n` })
+    }
+    return { target, found: true, removed: false, error }
+  }
+
+  if (ondata) {
+    ondata({ raw: `removed legacy path: ${target}\r\n` })
+  }
+  return { target, found: true, removed: true }
+}
+
+async function run(kernel, ondata) {
+  const results = []
+  const hookFailures = []
+
+  for (const target of legacyFfmpegHookFiles(kernel)) {
+    const result = await removeLegacyPath(target, ondata)
+    results.push(result)
+    if (result.found && !result.removed) {
+      hookFailures.push(result)
+    }
+  }
+
+  if (hookFailures.length > 0) {
+    throw new LegacyFfmpegCleanupError(hookFailures)
+  }
+
+  for (const target of legacyFfmpegRuntimePaths(kernel)) {
+    results.push(await removeLegacyPath(target, ondata))
+  }
+
+  return results
+}
+
+module.exports = {
+  LegacyFfmpegCleanupError,
+  hasCleanupTargets,
+  legacyFfmpegHookFiles,
+  legacyFfmpegRuntimePaths,
+  name: 'ffmpeg',
+  run,
+}

package/kernel/legacy_cleanup/index.js

@@ -0,0 +1,47 @@
+const path = require('path')
+const ffmpeg = require('./ffmpeg')
+
+const CLEANUPS = [
+  ffmpeg,
+]
+
+class LegacyCleanup {
+  constructor(kernel) {
+    this.kernel = kernel
+    this.promises = new Map()
+  }
+
+  async runOnce(ondata) {
+    const home = this.kernel && this.kernel.homedir ? path.resolve(this.kernel.homedir) : ''
+    if (this.promises.has(home)) {
+      return this.promises.get(home)
+    }
+    const promise = this.run(ondata).catch((error) => {
+      this.promises.delete(home)
+      throw error
+    })
+    this.promises.set(home, promise)
+    return promise
+  }
+
+  async run(ondata) {
+    if (!this.kernel || !this.kernel.homedir) {
+      return { skipped: true, results: [] }
+    }
+
+    const cleanupResults = []
+    for (const cleanup of CLEANUPS) {
+      if (await cleanup.hasCleanupTargets(this.kernel)) {
+        cleanupResults.push({
+          name: cleanup.name || 'legacy',
+          results: await cleanup.run(this.kernel, ondata),
+        })
+      }
+    }
+
+    return { skipped: false, results: cleanupResults }
+  }
+}
+
+module.exports = LegacyCleanup
+module.exports.ffmpeg = ffmpeg

package/kernel/procs.js

@@ -88,7 +88,7 @@ class Procs {
             continue
           }
 
-          //if (state !== 'LISTENING') continue;
+          if (state !== 'LISTENING') continue;
           const chunks = /(.+):([0-9]+)/.exec(localAddress)
           let host = chunks[1]
           let port = chunks[2]

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "pinokiod",
-  "version": "7.4.0",
+  "version": "7.4.2",
   "description": "",
   "main": "index.js",
   "scripts": {
     "download_readme": "wget -O kernel/proto/PINOKIO.md https://raw.githubusercontent.com/pinokiocomputer/home/refs/heads/main/docs/README.md",
-    "start": "node script/index",
-    "verify:ffmpeg": "node script/verify-ffmpeg.js"
+    "start": "node script/index"
   },
   "author": "",
   "license": "MIT",

package/server/views/app.ejs

@@ -19,6 +19,7 @@
 <% if (agent === "electron") { %>
   <link href="/electron.css" rel="stylesheet"/>
 <% } %>
+<% const appMobileBreakpointPx = 980 %>
 <style>
 :root {
   --assist-surface-light: var(--pinokio-chrome-accent-bg-light);
@@ -6169,7 +6170,7 @@ body.dark .pinokio-fork-dropdown-remote, body.dark .pinokio-publish-dropdown-rem
   }
 }
 */
-@media only screen and (max-width: 768px) {
+@media only screen and (max-width: <%= appMobileBreakpointPx %>px) {
   body {
     display: flex !important;
     flex-direction: row !important;
@@ -6410,7 +6411,7 @@ header.navheader h1 {
     margin: 0 10px;
   }
 }
-	@media only screen and (max-width: 768px) {
+	@media only screen and (max-width: <%= appMobileBreakpointPx %>px) {
 	  :root {
 	    --mobile-bottom-bar-height: calc(46px + env(safe-area-inset-bottom));
 	  }
@@ -8361,6 +8362,10 @@ body.dark .pinokio-custom-terminal-header {
   let pendingHomeSelectionRetry = null
   let initialWorkspaceDiskUsageRequested = false
   const openWithoutLaunching = <%- JSON.stringify(type === "run" && !autoselect) %>
+  const appMobileBreakpoint = <%= appMobileBreakpointPx %>
+  const appMobileBreakpointQuery = `(max-width: ${appMobileBreakpoint}px)`
+  window.PinokioAppMobileBreakpoint = appMobileBreakpoint
+  window.PinokioAppMobileBreakpointQuery = appMobileBreakpointQuery
   const scheduleSelectionRetry = (delay = 100) => {
     if (pendingSelectionRetry !== null) {
       return
@@ -11097,14 +11102,12 @@ const rerenderMenuSection = (container, html) => {
   }
 
 
-
-
-	  const mobileMenuQuery = window.matchMedia ? window.matchMedia("(max-width: 768px)") : null
+	  const mobileMenuQuery = window.matchMedia ? window.matchMedia(appMobileBreakpointQuery) : null
 	  const isMobileMenuOpen = () => document.body.classList.contains("mobile-menu-open")
 	  const appcanvas = document.querySelector(".appcanvas")
 	  const closeWindowButton = document.querySelector("#close-window")
 	  const mobileMenuBackdrop = document.querySelector("[data-mobile-menu-backdrop]")
-	  const isMobilePanelLayout = () => mobileMenuQuery ? mobileMenuQuery.matches : window.innerWidth <= 768
+	  const isMobilePanelLayout = () => mobileMenuQuery ? mobileMenuQuery.matches : window.innerWidth <= appMobileBreakpoint
 	  const normalizeMobilePanelName = (value) => {
 	    return value === "logs" || value === "ask-ai" || value === "feed" ? value : ""
 	  }
@@ -11844,7 +11847,7 @@ const rerenderMenuSection = (container, html) => {
   if (appcanvas && sidebarResizer && sidebarContainer) {
       const SIDEBAR_MIN_WIDTH = 140
       const SIDEBAR_MAX_WIDTH = 560
-      const sidebarMobileQuery = window.matchMedia ? window.matchMedia("(max-width: 768px)") : null
+      const sidebarMobileQuery = window.matchMedia ? window.matchMedia(appMobileBreakpointQuery) : null
       const workspaceName = "<%= typeof name === 'string' ? name : '' %>"
       const sidebarWidthStorageKey = workspaceName
         ? `pinokio-app-sidebar-width:${workspaceName}`
@@ -17862,7 +17865,7 @@ document.addEventListener("DOMContentLoaded", () => {
     enabled = false
   }
 
-  const communityModeQuery = window.matchMedia ? window.matchMedia("(max-width: 768px)") : null
+  const communityModeQuery = window.matchMedia ? window.matchMedia(window.PinokioAppMobileBreakpointQuery || "(max-width: <%= appMobileBreakpointPx %>px)") : null
   let communityMode = false
 
   const setCommunityMode = (next, opts) => {

package/test/ffmpeg-bin.test.js

@@ -0,0 +1,73 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+
+const Ffmpeg = require('../kernel/bin/ffmpeg')
+
+function createKernel(platform = 'win32') {
+  return {
+    platform,
+    bin: {
+      installed: {
+        conda: new Set(),
+        conda_versions: {},
+      },
+      exec: async () => {},
+    },
+  }
+}
+
+function createFfmpeg(kernel) {
+  const ffmpeg = new Ffmpeg()
+  ffmpeg.kernel = kernel
+  return ffmpeg
+}
+
+test('FFmpeg bin installs pinned ffmpeg into base Conda on Windows', async () => {
+  const calls = []
+  const kernel = createKernel('win32')
+  kernel.bin.exec = async (payload) => {
+    calls.push(payload)
+  }
+
+  await createFfmpeg(kernel).install({}, () => {})
+
+  assert.equal(calls.length, 1)
+  assert.deepEqual(calls[0].message, [
+    'conda clean -y --all',
+    'conda install -y --solver=classic --override-channels -c conda-forge "conda-libmamba-solver>=25.4.0" libmamba libmambapy libsolv libarchive',
+    'conda install -y --solver=classic --override-channels -c conda-forge ffmpeg=8.1.2',
+  ])
+  assert.equal(calls[0].env, undefined)
+  assert.equal(calls[0].message.some((command) => /ffmpeg-env|conda create|-p /.test(command)), false)
+})
+
+test('FFmpeg bin installs pinned ffmpeg into base Conda without Windows solver repair elsewhere', async () => {
+  const calls = []
+  const kernel = createKernel('darwin')
+  kernel.bin.exec = async (payload) => {
+    calls.push(payload)
+  }
+
+  await createFfmpeg(kernel).install({}, () => {})
+
+  assert.deepEqual(calls[0].message, [
+    'conda clean -y --all',
+    'conda install -y --override-channels -c conda-forge ffmpeg=8.1.2',
+  ])
+})
+
+test('FFmpeg installed check requires the base Conda package at the pinned version', async () => {
+  const kernel = createKernel('win32')
+  const ffmpeg = createFfmpeg(kernel)
+
+  kernel.bin.installed.conda = new Set(['ffmpeg'])
+  kernel.bin.installed.conda_versions = { ffmpeg: '8.1.2' }
+  assert.equal(await ffmpeg.installed(), true)
+
+  kernel.bin.installed.conda_versions = { ffmpeg: '8.1.1' }
+  assert.equal(await ffmpeg.installed(), false)
+
+  kernel.bin.installed.conda = new Set()
+  kernel.bin.installed.conda_versions = {}
+  assert.equal(await ffmpeg.installed(), false)
+})

package/test/legacy-cleanup.test.js

@@ -0,0 +1,161 @@
+const assert = require('node:assert/strict')
+const fsSync = require('node:fs')
+const fs = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const test = require('node:test')
+
+const LegacyCleanup = require('../kernel/legacy_cleanup')
+
+function createKernel(root) {
+  return {
+    homedir: root,
+    bin: {
+      path: (...parts) => path.join(root, 'bin', ...parts),
+    },
+  }
+}
+
+async function writeFixtureFile(filepath) {
+  await fs.mkdir(path.dirname(filepath), { recursive: true })
+  await fs.writeFile(filepath, 'legacy\n')
+}
+
+async function exists(filepath) {
+  try {
+    await fs.access(filepath)
+    return true
+  } catch (_) {
+    return false
+  }
+}
+
+async function createLegacyFfmpegState(root) {
+  const activate = path.join(root, 'bin', 'miniconda', 'etc', 'conda', 'activate.d')
+  const deactivate = path.join(root, 'bin', 'miniconda', 'etc', 'conda', 'deactivate.d')
+  const hooks = [
+    path.join(activate, 'zz_pinokio_ffmpeg.sh'),
+    path.join(activate, 'zz_pinokio_ffmpeg.bat'),
+    path.join(activate, 'zz_pinokio_ffmpeg.ps1'),
+    path.join(deactivate, 'zz_pinokio_ffmpeg.sh'),
+    path.join(deactivate, 'zz_pinokio_ffmpeg.bat'),
+    path.join(deactivate, 'zz_pinokio_ffmpeg.ps1'),
+  ]
+  for (const hook of hooks) {
+    await writeFixtureFile(hook)
+  }
+
+  const dirs = [
+    path.join(root, 'bin', 'ffmpeg-env'),
+    path.join(root, 'bin', 'ffmpeg-pkgs'),
+    path.join(root, 'bin', 'ffmpeg'),
+    path.join(root, 'bin', 'ffmpeg-tmp'),
+  ]
+  for (const dir of dirs) {
+    await fs.mkdir(dir, { recursive: true })
+    await fs.writeFile(path.join(dir, 'marker.txt'), 'legacy\n')
+  }
+
+  return { hooks, dirs }
+}
+
+test('LegacyCleanup removes stale FFmpeg Conda hooks and old runtime paths once at startup', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-legacy-cleanup-'))
+  const { hooks, dirs } = await createLegacyFfmpegState(root)
+  const packets = []
+  const cleanup = new LegacyCleanup(createKernel(root))
+
+  const result = await cleanup.runOnce((packet) => packets.push(packet))
+
+  assert.equal(result.skipped, false)
+  assert.ok(result.results.some((cleanupResult) => {
+    return cleanupResult.name === 'ffmpeg' &&
+      cleanupResult.results.some((item) => item.found && item.removed)
+  }))
+  for (const hook of hooks) {
+    assert.equal(await exists(hook), false, `${hook} should be removed`)
+  }
+  for (const dir of dirs) {
+    assert.equal(await exists(dir), false, `${dir} should be removed`)
+  }
+  assert.ok(packets.some((packet) => /removed legacy path:/.test(packet.raw || '')))
+})
+
+test('LegacyCleanup runOnce does not repeat work in the same process', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-legacy-once-'))
+  const kernel = createKernel(root)
+  const cleanup = new LegacyCleanup(kernel)
+  const first = await cleanup.runOnce(() => {})
+
+  const lateHook = path.join(root, 'bin', 'miniconda', 'etc', 'conda', 'activate.d', 'zz_pinokio_ffmpeg.bat')
+  await writeFixtureFile(lateHook)
+  const second = await cleanup.runOnce(() => {})
+
+  assert.strictEqual(second, first)
+  assert.equal(await exists(lateHook), true)
+})
+
+test('LegacyCleanup tells the user which stale FFmpeg hooks to delete when removal fails', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-legacy-locked-'))
+  await createLegacyFfmpegState(root)
+  const kernel = createKernel(root)
+  const originalRm = fsSync.promises.rm
+  const lockedHook = path.join(root, 'bin', 'miniconda', 'etc', 'conda', 'activate.d', 'zz_pinokio_ffmpeg.bat')
+  const packets = []
+
+  fsSync.promises.rm = async (target, options) => {
+    if (target === lockedHook) {
+      const error = new Error('locked')
+      error.code = 'EPERM'
+      throw error
+    }
+    return originalRm(target, options)
+  }
+
+  try {
+    await assert.rejects(
+      new LegacyCleanup(kernel).runOnce((packet) => packets.push(packet)),
+      (error) => {
+        assert.equal(error.name, 'LegacyFfmpegCleanupError')
+        assert.match(error.message, /Close all Pinokio windows/)
+        assert.match(error.message, /delete these files/)
+        assert.match(error.message, /zz_pinokio_ffmpeg\.bat/)
+        assert.ok(error.failures.some((failure) => failure.target === lockedHook))
+        return true
+      }
+    )
+    assert.ok(packets.some((packet) => /could not remove legacy path:/.test(packet.raw || '')))
+  } finally {
+    fsSync.promises.rm = originalRm
+  }
+})
+
+test('LegacyCleanup does not block startup when only an old FFmpeg runtime directory is locked', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-legacy-runtime-locked-'))
+  const runtimeDir = path.join(root, 'bin', 'ffmpeg-env')
+  await fs.mkdir(runtimeDir, { recursive: true })
+  await fs.writeFile(path.join(runtimeDir, 'marker.txt'), 'legacy\n')
+  const kernel = createKernel(root)
+  const originalRm = fsSync.promises.rm
+  const packets = []
+
+  fsSync.promises.rm = async (target, options) => {
+    if (target === runtimeDir) {
+      const error = new Error('locked')
+      error.code = 'EPERM'
+      throw error
+    }
+    return originalRm(target, options)
+  }
+
+  try {
+    const result = await new LegacyCleanup(kernel).runOnce((packet) => packets.push(packet))
+    assert.ok(result.results.some((cleanupResult) => {
+      return cleanupResult.name === 'ffmpeg' &&
+        cleanupResult.results.some((item) => item.target === runtimeDir && item.removed === false)
+    }))
+    assert.ok(packets.some((packet) => /could not remove legacy path:/.test(packet.raw || '')))
+  } finally {
+    fsSync.promises.rm = originalRm
+  }
+})

package/test/procs.test.js

@@ -0,0 +1,49 @@
+const assert = require("node:assert/strict")
+const os = require("node:os")
+const test = require("node:test")
+
+const procsPath = require.resolve("../kernel/procs")
+
+function loadProcsForPlatform(platform) {
+  const originalPlatform = os.platform
+  delete require.cache[procsPath]
+  os.platform = () => platform
+  try {
+    return require("../kernel/procs")
+  } finally {
+    os.platform = originalPlatform
+    delete require.cache[procsPath]
+  }
+}
+
+test("Windows process parser only probes listening TCP rows", async () => {
+  const Procs = loadProcsForPlatform("win32")
+  const procs = new Procs({})
+  const probed = []
+
+  procs.isHttp = async (host, port) => {
+    probed.push(`${host}:${port}`)
+    return true
+  }
+
+  const stdout = [
+    "  Proto  Local Address          Foreign Address        State           PID",
+    "  TCP    127.0.0.1:5173         0.0.0.0:0              LISTENING       1111",
+    "  TCP    127.0.0.1:49153        127.0.0.1:5173         ESTABLISHED     2222",
+    "  TCP    0.0.0.0:7860           0.0.0.0:0              LISTENING       3333",
+    "  TCP    [::1]:11434            [::]:0                 LISTENING       4444"
+  ].join("\n")
+
+  const results = await procs.get_pids(stdout)
+
+  assert.deepEqual(probed, [
+    "127.0.0.1:5173",
+    "0.0.0.0:7860",
+    "::1:11434"
+  ])
+  assert.deepEqual(results.map((item) => `${item.pid}:${item.ip}`), [
+    "1111:127.0.0.1:5173",
+    "3333:0.0.0.0:7860",
+    "4444:[::1]:11434"
+  ])
+})