pinokiod 7.4.2 → 7.5.0

package/kernel/legacy_cleanup/ffmpeg.js

@@ -1,167 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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/test/legacy-cleanup.test.js

@@ -1,161 +0,0 @@
-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
-  }
-})