pinokiod 7.4.1 → 7.4.3

package/kernel/bin/ffmpeg.js

@@ -1,5 +1,6 @@
 const RELEASE_VERSION = "8.1.2"
 const CONDA_SPEC = `ffmpeg=${RELEASE_VERSION}`
+const CONDA_CHANNEL_FLAGS = "--override-channels -c conda-forge"
 
 class Ffmpeg {
   description = "Installs FFmpeg for audio and video processing."
@@ -12,21 +13,19 @@ class Ffmpeg {
     await this.kernel.bin.exec({
       message: [
         "conda clean -y --all",
-        `conda install -y -c conda-forge ${this.cmd()}`
+        `conda install -y ${CONDA_CHANNEL_FLAGS} ${this.cmd()}`
       ]
     }, ondata)
   }
 
   async installed() {
-    return !!(
-      this.kernel.bin.installed?.conda?.has("ffmpeg") &&
-      this.kernel.bin.installed?.conda_versions?.ffmpeg === RELEASE_VERSION
-    )
+    return this.kernel.bin.installed.conda.has("ffmpeg") &&
+      this.kernel.bin.installed.conda_versions.ffmpeg === RELEASE_VERSION
   }
 
   async uninstall(req, ondata) {
     await this.kernel.bin.exec({
-      message: "conda remove ffmpeg",
+      message: "conda remove -y ffmpeg",
     }, ondata)
   }
 }

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,133 @@
+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 REMOVE_RETRY_COUNT = 5
+const REMOVE_RETRY_DELAY_MS = 100
+
+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))
+}
+
+async function removeLegacyPath(target, ondata) {
+  const existed = await pathExists(target)
+  if (!existed) {
+    return { target, found: false, removed: false }
+  }
+
+  try {
+    await 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/package.json

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

package/test/ffmpeg-bin.test.js

@@ -0,0 +1,72 @@
+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 --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 consistently across platforms', 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
+  }
+})