pinokiod 7.5.41 → 7.5.43

package/package.json

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

package/server/index.js

@@ -85,6 +85,7 @@ const { createTaskWorkspaceLinkService } = require("./lib/task_workspace_links")
 const { createContentValidationService } = require("./lib/content_validation")
 const { buildSecureRouterDebugSnapshot, createSecureRouterDebugStore } = require("./lib/secure_router_debug")
 const logRedaction = require("./lib/log_redaction")
+const privacyFilterCache = require("./lib/privacy_filter_cache")
 const AppRegistryService = require("./lib/app_registry")
 const AppLogService = require("./lib/app_logs")
 const AppLogReportService = require("./lib/app_log_report")
@@ -6401,6 +6402,12 @@ class Server {
         }
       });
       this.app.use('/files', serve2, serveIndex(this.kernel.homedir, {icons: true, hidden: true, theme: this.theme }))
+      this.app.use('/pinokio/privacy-filter/models', express.static(privacyFilterCache.cacheRoot(this.kernel), {
+        fallthrough: true,
+        index: false,
+        immutable: true,
+        maxAge: '1y'
+      }))
     } else {
       this.app.set("views", [
         path.resolve(__dirname, "views")
@@ -8415,6 +8422,24 @@ class Server {
         entries
       })
     }))
+    this.app.get("/pinokio/privacy-filter/status", ex(async (req, res) => {
+      const payload = await privacyFilterCache.status(this.kernel, {
+        dtype: req.query.dtype
+      })
+      res.set("Cache-Control", "no-store")
+      res.json(payload)
+    }))
+    this.app.post("/pinokio/privacy-filter/ensure", ex(async (req, res) => {
+      if (!privacyFilterCache.isInstallRequestAllowed(req)) {
+        res.status(403).json({ error: "Privacy filter cache install requires a same-origin request" })
+        return
+      }
+      const payload = await privacyFilterCache.ensure(this.kernel, {
+        dtype: req.query.dtype
+      })
+      res.set("Cache-Control", "no-store")
+      res.json(payload)
+    }))
     this.app.get("/pinokio/logs/file", ex(logRedaction.createTopLevelLogFileHandler(this)))
     this.app.get("/api/logs/stream", ex(async (req, res) => {
       const workspace = typeof req.query.workspace === 'string' ? req.query.workspace.trim() : ''
@@ -15991,12 +16016,21 @@ class Server {
         }
         return
       }
-      const redactionOverridesRequested = Boolean(req.body && Object.prototype.hasOwnProperty.call(req.body, 'redacted_overrides'))
+      const reviewedArchiveRequested = Boolean(req.body && (
+        Object.prototype.hasOwnProperty.call(req.body, 'redacted_overrides') ||
+        Object.prototype.hasOwnProperty.call(req.body, 'excluded_paths')
+      ))
+      const allowPartialOverrides = Boolean(req.body && (
+        req.body.allow_partial_overrides === true ||
+        req.body.allow_partial_overrides === 'true'
+      ))
       let redactionOverrides = []
+      let redactionExclusions = []
       try {
         redactionOverrides = logRedaction.normalizeLogRedactionOverrides(req.body || {})
+        redactionExclusions = logRedaction.normalizeLogRedactionExclusions(req.body || {})
       } catch (error) {
-        res.status(400).json({ error: error && error.message ? error.message : 'Invalid redaction overrides' })
+        res.status(400).json({ error: error && error.message ? error.message : 'Invalid redaction request' })
         return
       }
 
@@ -16014,22 +16048,26 @@ class Server {
 
       let folder = this.kernel.path("exported_logs")
       let zipPath = this.kernel.path("logs.zip")
-      if (redactionOverridesRequested) {
+      if (reviewedArchiveRequested) {
         await fs.promises.rm(zipPath, { force: true }).catch(() => {})
       }
       let appliedRedactionOverrides = 0
+      let appliedRedactionExclusions = 0
       try {
-        if (redactionOverridesRequested) {
-          await logRedaction.assertCompleteLogRedactionOverrides(folder, redactionOverrides)
+        if (reviewedArchiveRequested) {
+          await logRedaction.assertCompleteLogRedactionOverrides(folder, redactionOverrides, redactionExclusions, {
+            requireComplete: !allowPartialOverrides
+          })
         }
+        appliedRedactionExclusions = await logRedaction.applyLogRedactionExclusions(folder, redactionExclusions)
         appliedRedactionOverrides = await logRedaction.applyLogRedactionOverrides(folder, redactionOverrides)
       } catch (error) {
-        res.status(400).json({ error: error && error.message ? error.message : 'Failed to apply redaction overrides' })
+        res.status(400).json({ error: error && error.message ? error.message : 'Failed to apply redaction request' })
         return
       }
       await fs.promises.rm(zipPath, { force: true }).catch(() => {})
       await compressing.zip.compressDir(folder, zipPath)
-      res.json({ success: true, download: '/pinokio/logs.zip', redacted_overrides: appliedRedactionOverrides })
+      res.json({ success: true, download: '/pinokio/logs.zip', redacted_overrides: appliedRedactionOverrides, excluded_paths: appliedRedactionExclusions })
     }))
     this.app.get("/pinokio/version", ex(async (req, res) => {
       let version = this.version

package/server/lib/log_redaction.js

@@ -5,6 +5,7 @@ const { isBinaryFile } = require('isbinaryfile')
 const LOG_REDACTION_FILE_MAX_BYTES = 2 * 1024 * 1024
 const LOG_REDACTION_OVERRIDE_MAX_BYTES = 8 * 1024 * 1024
 const LOG_REDACTION_TEXT_EXTENSIONS = new Set(['.json', '.log', '.txt'])
+const LOG_REDACTION_TAIL_LINE_COUNTS = new Set([500, 1000, 2000])
 const CADDY_LOG_PATTERN = /^caddy(?:-.+)?\.log$/i
 
 function isTopLevelRedactableLogPath(relativePath = '') {
@@ -21,8 +22,84 @@ function isTopLevelRedactableLogPath(relativePath = '') {
   return LOG_REDACTION_TEXT_EXTENSIONS.has(path.extname(value).toLowerCase())
 }
 
+function normalizeTailLineCount(value) {
+  const parsed = Number.parseInt(String(value || ''), 10)
+  return LOG_REDACTION_TAIL_LINE_COUNTS.has(parsed) ? parsed : 0
+}
+
+async function readTailTextFile(filePath, stats, tailLines) {
+  const readBytes = Math.min(stats.size, LOG_REDACTION_FILE_MAX_BYTES - 2048)
+  const start = Math.max(0, stats.size - readBytes)
+  const buffer = Buffer.alloc(readBytes)
+  const handle = await fs.promises.open(filePath, 'r')
+  let bytesRead = 0
+  try {
+    const result = await handle.read(buffer, 0, readBytes, start)
+    bytesRead = result.bytesRead
+  } finally {
+    await handle.close()
+  }
+  let text = buffer.slice(0, bytesRead).toString('utf8')
+  if (start > 0) {
+    const firstNewline = text.indexOf('\n')
+    if (firstNewline >= 0) {
+      text = text.slice(firstNewline + 1)
+    }
+  }
+  const lines = text.split(/\r?\n/)
+  const selected = lines.length > tailLines ? lines.slice(-tailLines) : lines
+  const omittedLines = Math.max(0, lines.length - selected.length)
+  const prefix = start > 0 || omittedLines > 0
+    ? `[Older log content omitted by user. Showing the last ${tailLines.toLocaleString()} lines.]\n`
+    : ''
+  return {
+    text: `${prefix}${selected.join('\n')}`,
+    truncated: start > 0 || omittedLines > 0,
+    included_lines: selected.length
+  }
+}
+
+function clonePlainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? { ...value }
+    : {}
+}
+
+function createRuntimeEnvSnapshot(kernel) {
+  const baseEnv = {
+    ...clonePlainObject(process.env),
+    ...clonePlainObject(kernel && kernel.envs)
+  }
+  if (kernel && kernel.bin && typeof kernel.bin.envs === 'function') {
+    try {
+      return clonePlainObject(kernel.bin.envs(baseEnv))
+    } catch (_) {}
+  }
+  return baseEnv
+}
+
+function createFallbackStateSnapshot(kernel) {
+  const env = createRuntimeEnvSnapshot(kernel)
+  if (Object.keys(env).length === 0) {
+    return null
+  }
+  return {
+    state: 'snapshot',
+    id: 'runtime-environment',
+    group: 'system',
+    env,
+    path: kernel && kernel.homedir,
+    cmd: 'pinokio environment snapshot',
+    done: true,
+    ready: true
+  }
+}
+
 function createCurrentLogSnapshot(kernel, version) {
-  const states = kernel.shell.shells.map((s) => {
+  const liveShells = kernel && kernel.shell && Array.isArray(kernel.shell.shells)
+    ? kernel.shell.shells
+    : []
+  const states = liveShells.map((s) => {
     return {
       state: s.state,
       id: s.id,
@@ -34,6 +111,12 @@ function createCurrentLogSnapshot(kernel, version) {
       ready: s.ready,
     }
   })
+  if (states.length === 0) {
+    const fallbackState = createFallbackStateSnapshot(kernel)
+    if (fallbackState) {
+      states.push(fallbackState)
+    }
+  }
 
   const info = {
     platform: kernel.platform,
@@ -104,12 +187,45 @@ function normalizeLogRedactionOverrides(body = {}) {
   return overrides
 }
 
-async function assertCompleteLogRedactionOverrides(exportRoot, overrides = []) {
+function normalizeLogRedactionExclusions(body = {}) {
+  if (!body || !Object.prototype.hasOwnProperty.call(body, 'excluded_paths')) {
+    return []
+  }
+  const source = body.excluded_paths
+  if (!Array.isArray(source)) {
+    throw new Error('excluded_paths must be an array')
+  }
+  const exclusions = []
+  const seen = new Set()
+  for (const candidate of source) {
+    const relativePath = typeof candidate === 'string' ? candidate.trim() : ''
+    if (!isTopLevelRedactableLogPath(relativePath)) {
+      throw new Error(`Invalid excluded path: ${relativePath || '(empty)'}`)
+    }
+    if (seen.has(relativePath)) {
+      throw new Error(`Duplicate excluded path: ${relativePath}`)
+    }
+    seen.add(relativePath)
+    exclusions.push(relativePath)
+  }
+  return exclusions
+}
+
+async function assertCompleteLogRedactionOverrides(exportRoot, overrides = [], exclusions = [], options = {}) {
   const overridePaths = new Set((Array.isArray(overrides) ? overrides : []).map((override) => override && override.path).filter(Boolean))
+  const excludedPaths = new Set(Array.isArray(exclusions) ? exclusions.filter(Boolean) : [])
+  for (const excludedPath of excludedPaths) {
+    if (overridePaths.has(excludedPath)) {
+      throw new Error(`File cannot be both redacted and excluded: ${excludedPath}`)
+    }
+  }
+  if (options && options.requireComplete === false) {
+    return
+  }
   const missing = []
   const entries = await fs.promises.readdir(exportRoot, { withFileTypes: true })
   for (const entry of entries) {
-    if (entry.isFile() && isTopLevelRedactableLogPath(entry.name) && !overridePaths.has(entry.name)) {
+    if (entry.isFile() && isTopLevelRedactableLogPath(entry.name) && !overridePaths.has(entry.name) && !excludedPaths.has(entry.name)) {
       missing.push(entry.name)
     }
   }
@@ -119,6 +235,35 @@ async function assertCompleteLogRedactionOverrides(exportRoot, overrides = []) {
   }
 }
 
+async function applyLogRedactionExclusions(exportRoot, exclusions = []) {
+  if (!Array.isArray(exclusions) || exclusions.length === 0) {
+    return 0
+  }
+  let removed = 0
+  for (const relativePath of exclusions) {
+    if (!isTopLevelRedactableLogPath(relativePath)) {
+      throw new Error(`Invalid excluded path: ${relativePath || '(empty)'}`)
+    }
+    const target = path.resolve(exportRoot, relativePath)
+    const relative = path.relative(exportRoot, target)
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative) || relative.includes(path.sep)) {
+      throw new Error(`Invalid excluded path: ${relativePath}`)
+    }
+    let stats
+    try {
+      stats = await fs.promises.stat(target)
+    } catch (_) {
+      throw new Error(`Excluded path target not found: ${relativePath}`)
+    }
+    if (!stats.isFile()) {
+      throw new Error(`Excluded path target is not a file: ${relativePath}`)
+    }
+    await fs.promises.rm(target, { force: true })
+    removed += 1
+  }
+  return removed
+}
+
 async function applyLogRedactionOverrides(exportRoot, overrides = []) {
   if (!Array.isArray(overrides) || overrides.length === 0) {
     return 0
@@ -215,6 +360,7 @@ function createTopLevelLogFileHandler(server) {
       res.status(400).json({ error: 'Only top-level text log files can be read for redaction' })
       return
     }
+    const tailLines = normalizeTailLineCount(req.query.tail_lines || req.query.lines)
     let stats
     try {
       stats = await fs.promises.stat(descriptor.absolutePath)
@@ -226,7 +372,7 @@ function createTopLevelLogFileHandler(server) {
       res.status(400).json({ error: 'Path is not a file' })
       return
     }
-    if (stats.size > LOG_REDACTION_FILE_MAX_BYTES) {
+    if (stats.size > LOG_REDACTION_FILE_MAX_BYTES && !tailLines) {
       res.status(413).json({
         error: 'File is too large to redact in the browser',
         size: stats.size,
@@ -242,8 +388,14 @@ function createTopLevelLogFileHandler(server) {
       }
     } catch (_) {}
     let text
+    let tail = null
     try {
-      text = await fs.promises.readFile(descriptor.absolutePath, 'utf8')
+      if (tailLines) {
+        tail = await readTailTextFile(descriptor.absolutePath, stats, tailLines)
+        text = tail.text
+      } else {
+        text = await fs.promises.readFile(descriptor.absolutePath, 'utf8')
+      }
     } catch (error) {
       res.status(500).json({ error: 'Failed to read file', detail: error.message })
       return
@@ -254,6 +406,9 @@ function createTopLevelLogFileHandler(server) {
       name: path.basename(relativePath),
       size: stats.size,
       modified: stats.mtime,
+      tail_lines: tailLines || null,
+      truncated: tail ? tail.truncated : false,
+      included_lines: tail ? tail.included_lines : null,
       text
     })
   }
@@ -262,10 +417,13 @@ function createTopLevelLogFileHandler(server) {
 module.exports = {
   LOG_REDACTION_FILE_MAX_BYTES,
   isTopLevelRedactableLogPath,
+  normalizeTailLineCount,
   createCurrentLogSnapshot,
   writeCurrentLogSnapshot,
   normalizeLogRedactionOverrides,
+  normalizeLogRedactionExclusions,
   assertCompleteLogRedactionOverrides,
+  applyLogRedactionExclusions,
   applyLogRedactionOverrides,
   createLogRedactionBodyParser,
   createLogRedactionBodyParsers,

package/server/lib/privacy_filter_cache.js

@@ -0,0 +1,286 @@
+const fs = require('fs')
+const path = require('path')
+const { pipeline } = require('stream/promises')
+const axios = require('axios')
+
+const PRIVACY_FILTER_MODEL_ID = 'openai/privacy-filter'
+const PRIVACY_FILTER_REVISION = '7ffa9a043d54d1be65afb281eddf0ffbe629385b'
+const PRIVACY_FILTER_LOCAL_MODEL_PATH = `/pinokio/privacy-filter/models/${PRIVACY_FILTER_REVISION}/`
+const PRIVACY_FILTER_SHARED_FILES = [
+  'config.json',
+  'tokenizer_config.json',
+  'tokenizer.json'
+]
+const PRIVACY_FILTER_DTYPE_FILES = {
+  q4f16: [
+    'onnx/model_q4f16.onnx',
+    'onnx/model_q4f16.onnx_data'
+  ],
+  q4: [
+    'onnx/model_q4.onnx',
+    'onnx/model_q4.onnx_data'
+  ],
+  q8: [
+    'onnx/model_quantized.onnx',
+    'onnx/model_quantized.onnx_data'
+  ]
+}
+const PRIVACY_FILTER_ASSET_SET = new Set([
+  ...PRIVACY_FILTER_SHARED_FILES,
+  ...Object.values(PRIVACY_FILTER_DTYPE_FILES).flat()
+])
+
+const ensurePromises = new Map()
+const installStates = new Map()
+
+function normalizeDtype(value) {
+  const dtype = String(value || '').trim().toLowerCase()
+  return Object.prototype.hasOwnProperty.call(PRIVACY_FILTER_DTYPE_FILES, dtype) ? dtype : 'q8'
+}
+
+function cacheRoot(kernel) {
+  const home = kernel && typeof kernel.homedir === 'string' ? kernel.homedir : ''
+  if (!home.trim()) {
+    throw new Error('Pinokio home directory is required for privacy filter cache.')
+  }
+  return path.resolve(home, 'cache', 'privacy-filter', 'models')
+}
+
+function modelRoot(kernel) {
+  return path.resolve(cacheRoot(kernel), PRIVACY_FILTER_REVISION, 'openai', 'privacy-filter')
+}
+
+function assetFilesForDtype(dtype) {
+  const normalized = normalizeDtype(dtype)
+  return [
+    ...PRIVACY_FILTER_SHARED_FILES,
+    ...PRIVACY_FILTER_DTYPE_FILES[normalized]
+  ]
+}
+
+function assertKnownAsset(relativePath) {
+  const normalized = String(relativePath || '').replace(/\\/g, '/')
+  if (!PRIVACY_FILTER_ASSET_SET.has(normalized)) {
+    throw new Error(`Unknown privacy filter asset: ${relativePath}`)
+  }
+  return normalized
+}
+
+function isInstallRequestAllowed(req) {
+  const fetchSite = String(req && typeof req.get === 'function' ? req.get('Sec-Fetch-Site') || '' : '').trim().toLowerCase()
+  if (fetchSite && fetchSite !== 'same-origin' && fetchSite !== 'none') {
+    return false
+  }
+
+  const origin = String(req && typeof req.get === 'function' ? req.get('Origin') || '' : '').trim()
+  if (!origin) {
+    return true
+  }
+
+  const host = String(req && typeof req.get === 'function' ? req.get('Host') || '' : '').trim().toLowerCase()
+  if (!host) {
+    return false
+  }
+
+  try {
+    const parsed = new URL(origin)
+    return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.host.toLowerCase() === host
+  } catch (_) {
+    return false
+  }
+}
+
+function assetPath(kernel, relativePath) {
+  const normalized = assertKnownAsset(relativePath)
+  return path.resolve(modelRoot(kernel), ...normalized.split('/'))
+}
+
+function ensureKey(kernel, dtype) {
+  return `${modelRoot(kernel)}:${normalizeDtype(dtype)}`
+}
+
+function remoteAssetUrl(relativePath) {
+  const normalized = assertKnownAsset(relativePath)
+  return `https://huggingface.co/${PRIVACY_FILTER_MODEL_ID}/resolve/${PRIVACY_FILTER_REVISION}/${normalized}`
+}
+
+function copyInstallState(install) {
+  return install ? { ...install } : null
+}
+
+async function cleanupStaleAssetTemps(target) {
+  const dir = path.dirname(target)
+  const base = path.basename(target)
+  const currentProcessPrefix = `${base}.${process.pid}.`
+  let entries
+  try {
+    entries = await fs.promises.readdir(dir, { withFileTypes: true })
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return
+    }
+    throw error
+  }
+  await Promise.all(entries
+    .filter((entry) => {
+      return entry.isFile() &&
+        entry.name.startsWith(`${base}.`) &&
+        entry.name.endsWith('.tmp') &&
+        !entry.name.startsWith(currentProcessPrefix)
+    })
+    .map((entry) => fs.promises.rm(path.resolve(dir, entry.name), { force: true })))
+}
+
+async function fileStatus(kernel, relativePath) {
+  const target = assetPath(kernel, relativePath)
+  try {
+    const stats = await fs.promises.stat(target)
+    return {
+      path: relativePath,
+      exists: stats.isFile() && stats.size > 0,
+      size: stats.isFile() ? stats.size : 0
+    }
+  } catch (_) {
+    return {
+      path: relativePath,
+      exists: false,
+      size: 0
+    }
+  }
+}
+
+async function status(kernel, options = {}) {
+  const dtype = normalizeDtype(options.dtype)
+  const install = copyInstallState(installStates.get(ensureKey(kernel, dtype)))
+  const files = await Promise.all(assetFilesForDtype(dtype).map((file) => fileStatus(kernel, file)))
+  const missing = files.filter((file) => !file.exists).map((file) => file.path)
+  return {
+    model_id: PRIVACY_FILTER_MODEL_ID,
+    revision: PRIVACY_FILTER_REVISION,
+    dtype,
+    local_model_path: PRIVACY_FILTER_LOCAL_MODEL_PATH,
+    ready: missing.length === 0,
+    files,
+    missing,
+    missing_count: missing.length,
+    installing: Boolean(install),
+    install
+  }
+}
+
+async function downloadAsset(kernel, relativePath, onProgress) {
+  const target = assetPath(kernel, relativePath)
+  const existing = await fileStatus(kernel, relativePath)
+  if (existing.exists) {
+    return { path: relativePath, status: 'cached', size: existing.size }
+  }
+
+  await fs.promises.mkdir(path.dirname(target), { recursive: true })
+  await cleanupStaleAssetTemps(target)
+  const tmp = `${target}.${process.pid}.${Date.now()}.tmp`
+  try {
+    const response = await axios.get(remoteAssetUrl(relativePath), {
+      responseType: 'stream',
+      maxRedirects: 5,
+      timeout: 0,
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+      validateStatus: (statusCode) => statusCode >= 200 && statusCode < 300
+    })
+    let loaded = 0
+    const total = Number(response.headers && response.headers['content-length']) || 0
+    const encoded = Boolean(response.headers && response.headers['content-encoding'])
+    if (typeof onProgress === 'function') {
+      onProgress({ loaded, total })
+    }
+    response.data.on('data', (chunk) => {
+      loaded += chunk && chunk.length ? chunk.length : 0
+      if (typeof onProgress === 'function') {
+        onProgress({ loaded, total })
+      }
+    })
+    await pipeline(response.data, fs.createWriteStream(tmp))
+    const stats = await fs.promises.stat(tmp)
+    if (!stats.isFile() || stats.size <= 0) {
+      throw new Error(`Downloaded empty privacy filter asset: ${relativePath}`)
+    }
+    if (total > 0 && !encoded && stats.size !== total) {
+      throw new Error(`Incomplete privacy filter asset: ${relativePath} (${stats.size}/${total} bytes)`)
+    }
+    await fs.promises.rename(tmp, target)
+    return { path: relativePath, status: 'downloaded', size: stats.size }
+  } catch (error) {
+    await fs.promises.rm(tmp, { force: true }).catch(() => {})
+    throw error
+  }
+}
+
+async function ensure(kernel, options = {}) {
+  const dtype = normalizeDtype(options.dtype)
+  const key = ensureKey(kernel, dtype)
+  if (ensurePromises.has(key)) {
+    return ensurePromises.get(key)
+  }
+  const promise = (async () => {
+    const files = assetFilesForDtype(dtype)
+    const install = {
+      dtype,
+      total_files: files.length,
+      completed_files: 0,
+      cached_files: 0,
+      downloaded_files: 0,
+      current_file: '',
+      current_loaded: 0,
+      current_total: 0,
+      started_at: new Date().toISOString(),
+      updated_at: new Date().toISOString()
+    }
+    installStates.set(key, install)
+    const results = []
+    for (let index = 0; index < files.length; index += 1) {
+      const file = files[index]
+      install.current_file = file
+      install.current_index = index + 1
+      install.current_loaded = 0
+      install.current_total = 0
+      install.updated_at = new Date().toISOString()
+      const result = await downloadAsset(kernel, file, ({ loaded, total }) => {
+        install.current_loaded = loaded
+        install.current_total = total
+        install.updated_at = new Date().toISOString()
+      })
+      results.push(result)
+      install.completed_files += 1
+      if (result.status === 'cached') {
+        install.cached_files += 1
+      } else if (result.status === 'downloaded') {
+        install.downloaded_files += 1
+      }
+      install.updated_at = new Date().toISOString()
+    }
+    const current = await status(kernel, { dtype })
+    return {
+      ...current,
+      results,
+      downloaded: results.filter((result) => result.status === 'downloaded').length,
+      cached: results.filter((result) => result.status === 'cached').length
+    }
+  })().finally(() => {
+    ensurePromises.delete(key)
+    installStates.delete(key)
+  })
+  ensurePromises.set(key, promise)
+  return promise
+}
+
+module.exports = {
+  PRIVACY_FILTER_MODEL_ID,
+  PRIVACY_FILTER_REVISION,
+  PRIVACY_FILTER_LOCAL_MODEL_PATH,
+  normalizeDtype,
+  cacheRoot,
+  modelRoot,
+  isInstallRequestAllowed,
+  status,
+  ensure
+}