bytifi 0.2.5 → 0.2.7

package/lib/decrypt.js

@@ -9,15 +9,24 @@ import {
   usesChunkCompression,
 } from './crypto.js'
 import { fromBase64Url } from './base64url.js'
-import { BytifiApiError, fetchPublicBinaryWithRetry, publicFetchWithRetry } from './upload.js'
+import { fetchPublicBinaryWithRetry, publicFetchWithRetry } from './api.js'
+import { normalizeBaseUrl } from './url.js'
 
-const DEFAULT_BASE_URL = 'https://bytifi.com'
+const DEFAULT_DECRYPT_CONCURRENCY = 2
 
-function normalizeBaseUrl(baseUrl) {
-  return String(baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '')
+function decryptProgress(overrides) {
+  return { stage: 'decrypting', percent: 0, ...overrides }
 }
 
-export function parseDecryptInput(input, { encryptionToken = '', baseUrl = DEFAULT_BASE_URL } = {}) {
+function resolveDecryptConcurrency(requested) {
+  const value = Number(requested)
+  if (Number.isFinite(value) && value > 0) {
+    return Math.min(8, Math.max(1, Math.floor(value)))
+  }
+  return DEFAULT_DECRYPT_CONCURRENCY
+}
+
+export function parseDecryptInput(input, { encryptionToken = '', baseUrl = undefined } = {}) {
   const trimmed = String(input || '').trim()
   if (!trimmed) {
     throw new Error('Missing share URL or link token.')
@@ -67,7 +76,7 @@ export function parseDecryptInput(input, { encryptionToken = '', baseUrl = DEFAU
   }
 }
 
-export function parseShareReference(input, { encryptionToken = '', baseUrl = DEFAULT_BASE_URL } = {}) {
+export function parseShareReference(input, { encryptionToken = '', baseUrl = undefined } = {}) {
   const trimmed = String(input || '').trim()
   if (!trimmed) {
     return {
@@ -127,16 +136,16 @@ async function resolveEncryptionMeta({
   metaPath = '',
   inlineMeta = null,
   linkToken = '',
-  baseUrl = DEFAULT_BASE_URL,
+  baseUrl,
   signal,
   onStatus,
 }) {
   if (inlineMeta) {
-    return { meta: inlineMeta }
+    return { meta: inlineMeta, skipApiMetaFetch: true }
   }
 
   if (metaPath) {
-    return { meta: await readMetaFile(metaPath) }
+    return { meta: await readMetaFile(metaPath), skipApiMetaFetch: true }
   }
 
   if (!linkToken) {
@@ -169,6 +178,10 @@ function sanitizeOutputName(filename) {
   return base || 'download'
 }
 
+async function cleanupPartialOutput(outputPath) {
+  await fs.unlink(outputPath).catch(() => {})
+}
+
 async function fetchLinkInfo(baseUrl, linkToken, signal, onStatus) {
   return publicFetchWithRetry(baseUrl, `/api/link/${encodeURIComponent(linkToken)}`, { signal, onStatus })
 }
@@ -181,6 +194,14 @@ async function fetchEncryptedPart(baseUrl, linkToken, partNumber, signal, onStat
   )
 }
 
+function splitDownloadUrl(encryptedFileUrl, fallbackBaseUrl) {
+  const url = new URL(encryptedFileUrl, `${normalizeBaseUrl(fallbackBaseUrl)}/`)
+  return {
+    baseUrl: `${url.protocol}//${url.host}`,
+    path: `${url.pathname}${url.search}`,
+  }
+}
+
 async function decryptFromParts({
   baseUrl,
   linkToken,
@@ -191,38 +212,48 @@ async function decryptFromParts({
   onProgress,
   onStatus,
   signal,
+  concurrency = DEFAULT_DECRYPT_CONCURRENCY,
 }) {
   const { chunks } = buildEncryptedChunkPlan(meta)
   const fileHandle = await fs.open(outputPath, 'w')
   let decryptedBytes = 0
+  const workerCount = Math.min(resolveDecryptConcurrency(concurrency), chunks.length)
+  let nextIndex = 0
+  let completedParts = 0
+  let inFlightParts = 0
 
-  try {
-    for (let index = 0; index < chunks.length; index += 1) {
-      if (signal?.aborted) {
-        throw new Error('Decrypt aborted.')
-      }
+  function partPercent() {
+    const weighted = completedParts + inFlightParts * 0.5
+    return Math.min(100, Math.round((weighted / chunks.length) * 100))
+  }
 
-      const chunk = chunks[index]
-      const partNumber = chunk.chunkIndex + 1
+  async function processPart(index) {
+    if (signal?.aborted) {
+      throw new Error('Decrypt aborted.')
+    }
+
+    const chunk = chunks[index]
+    const partNumber = chunk.chunkIndex + 1
+    inFlightParts += 1
 
-      onProgress?.({
+    try {
+      onProgress?.(decryptProgress({
         stage: 'downloading',
         part: partNumber,
         totalParts: chunks.length,
-        downloadedBytes: decryptedBytes,
         totalBytes: meta.originalSize,
-        percent: Math.round((decryptedBytes / meta.originalSize) * 100),
-      })
+        percent: partPercent(),
+      }))
 
       const encryptedPart = await fetchEncryptedPart(baseUrl, linkToken, partNumber, signal, onStatus)
 
-      onProgress?.({
+      onProgress?.(decryptProgress({
         stage: 'decrypting',
         part: partNumber,
         totalParts: chunks.length,
         partBytes: encryptedPart.length,
-        percent: Math.round((decryptedBytes / meta.originalSize) * 100),
-      })
+        percent: partPercent(),
+      }))
 
       const plainPart = await decryptPlainChunkFromEncrypted(
         encryptedPart,
@@ -232,19 +263,45 @@ async function decryptFromParts({
         meta,
       )
 
-      await fileHandle.write(plainPart)
-      decryptedBytes += plainPart.length
+      return { index, partNumber, plainPart }
+    } finally {
+      inFlightParts -= 1
+    }
+  }
 
-      onProgress?.({
-        stage: 'writing',
-        part: partNumber,
-        totalParts: chunks.length,
-        downloadedBytes: decryptedBytes,
-        totalBytes: meta.originalSize,
-        percent: Math.round((decryptedBytes / meta.originalSize) * 100),
-        detail: `${partNumber}/${chunks.length} parts`,
-      })
+  try {
+    const results = new Array(chunks.length)
+    const workers = Array.from({ length: workerCount }, async () => {
+      while (true) {
+        const index = nextIndex
+        nextIndex += 1
+        if (index >= chunks.length) return
+
+        const result = await processPart(index)
+        results[result.index] = result.plainPart
+        completedParts += 1
+        decryptedBytes += result.plainPart.length
+
+        onProgress?.(decryptProgress({
+          stage: 'writing',
+          part: result.partNumber,
+          totalParts: chunks.length,
+          downloadedBytes: decryptedBytes,
+          totalBytes: meta.originalSize,
+          percent: Math.round((decryptedBytes / meta.originalSize) * 100),
+          detail: `${completedParts}/${chunks.length} parts`,
+        }))
+      }
+    })
+
+    await Promise.all(workers)
+
+    for (const plainPart of results) {
+      await fileHandle.write(plainPart)
     }
+  } catch (error) {
+    await cleanupPartialOutput(outputPath)
+    throw error
   } finally {
     await fileHandle.close()
   }
@@ -259,17 +316,11 @@ async function decryptFromSingleFile({
   noncePrefix,
   outputPath,
   onProgress,
+  onStatus,
   signal,
+  baseUrl,
 }) {
-  const response = await fetch(encryptedFileUrl, { signal })
-
-  if (!response.ok) {
-    const text = await response.text()
-    throw new BytifiApiError(text || 'Failed to download encrypted file.', {
-      status: response.status,
-      body: text,
-    })
-  }
+  const { baseUrl: downloadBaseUrl, path: downloadPath } = splitDownloadUrl(encryptedFileUrl, baseUrl)
 
   if (usesChunkCompression(meta)) {
     if (meta.chunkCount !== 1) {
@@ -278,7 +329,7 @@ async function decryptFromSingleFile({
       )
     }
 
-    const encryptedBuffer = Buffer.from(await response.arrayBuffer())
+    const encryptedBuffer = await fetchPublicBinaryWithRetry(downloadBaseUrl, downloadPath, { signal, onStatus })
     const plainPart = await decryptPlainChunkFromEncrypted(
       encryptedBuffer,
       tokenBytes,
@@ -286,93 +337,27 @@ async function decryptFromSingleFile({
       0,
       meta,
     )
-    await fs.writeFile(outputPath, plainPart)
-    onProgress?.(100)
-    return
-  }
 
-  const { chunks, totalEncryptedSize } = buildEncryptedChunkPlan(meta)
+    try {
+      await fs.writeFile(outputPath, plainPart)
+    } catch (error) {
+      await cleanupPartialOutput(outputPath)
+      throw error
+    }
 
-  if (!response.body) {
-    const encryptedBuffer = Buffer.from(await response.arrayBuffer())
-    await writeDecryptedBuffer(encryptedBuffer, chunks, meta, tokenBytes, noncePrefix, outputPath, onProgress, signal)
+    onProgress?.({ stage: 'complete', percent: 100 })
     return
   }
 
-  const reader = response.body.getReader()
-  const fileHandle = await fs.open(outputPath, 'w')
-  const pending = []
-  let pendingLength = 0
-  let downloadedBytes = 0
-  let nextChunkIndex = 0
-  let decryptedBytes = 0
-
-  const takeBytes = (length) => {
-    while (pendingLength < length) {
-      return null
-    }
-
-    const out = Buffer.alloc(length)
-    let offset = 0
-
-    while (offset < length) {
-      const head = pending[0]
-      const take = Math.min(length - offset, head.length)
-      head.copy(out, offset, 0, take)
-      offset += take
-
-      if (take === head.length) {
-        pending.shift()
-      } else {
-        pending[0] = head.subarray(take)
-      }
-      pendingLength -= take
-    }
-
-    return out
-  }
+  const { chunks, totalEncryptedSize } = buildEncryptedChunkPlan(meta)
+  const encryptedBuffer = await fetchPublicBinaryWithRetry(downloadBaseUrl, downloadPath, { signal, onStatus })
 
   try {
-    while (nextChunkIndex < chunks.length) {
-      if (signal?.aborted) {
-        throw new Error('Decrypt aborted.')
-      }
-
-      const chunk = chunks[nextChunkIndex]
-
-      while (pendingLength < chunk.encryptedSize) {
-        const { done, value } = await reader.read()
-        if (done) break
-        const buffer = Buffer.from(value)
-        pending.push(buffer)
-        pendingLength += buffer.length
-        downloadedBytes += buffer.length
-        onProgress?.(Math.min(99, Math.round((downloadedBytes / totalEncryptedSize) * 100)))
-      }
-
-      const encryptedChunk = takeBytes(chunk.encryptedSize)
-      if (!encryptedChunk) {
-        throw new Error('Encrypted file ended before all parts were downloaded.')
-      }
-
-      const plainPart = await decryptPlainChunkFromEncrypted(
-        encryptedChunk,
-        tokenBytes,
-        noncePrefix,
-        chunk.chunkIndex,
-        meta,
-      )
-      await fileHandle.write(plainPart)
-      decryptedBytes += plainPart.length
-      nextChunkIndex += 1
-      onProgress?.(Math.min(99, Math.round((decryptedBytes / meta.originalSize) * 100)))
-    }
-  } finally {
-    await reader.cancel().catch(() => {})
-    await fileHandle.close()
+    await writeDecryptedBuffer(encryptedBuffer, chunks, meta, tokenBytes, noncePrefix, outputPath, onProgress, signal)
+  } catch (error) {
+    await cleanupPartialOutput(outputPath)
+    throw error
   }
-
-  onProgress?.(100)
 }
 
 async function writeDecryptedBuffer(encryptedBuffer, chunks, meta, tokenBytes, noncePrefix, outputPath, onProgress, signal) {
@@ -389,7 +374,7 @@ async function writeDecryptedBuffer(encryptedBuffer, chunks, meta, tokenBytes, n
       meta,
     )
     await fs.writeFile(outputPath, plainPart)
-    onProgress?.(100)
+    onProgress?.({ stage: 'complete', percent: 100 })
     return
   }
 
@@ -418,13 +403,21 @@ async function writeDecryptedBuffer(encryptedBuffer, chunks, meta, tokenBytes, n
       await fileHandle.write(plainPart)
       offset += chunk.encryptedSize
       decryptedBytes += plainPart.length
-      onProgress?.(Math.round((decryptedBytes / meta.originalSize) * 100))
+      onProgress?.(decryptProgress({
+        stage: 'decrypting',
+        part: chunk.chunkIndex + 1,
+        totalParts: chunks.length,
+        percent: Math.round((decryptedBytes / meta.originalSize) * 100),
+      }))
     }
+  } catch (error) {
+    await cleanupPartialOutput(outputPath)
+    throw error
   } finally {
     await fileHandle.close()
   }
 
-  onProgress?.(100)
+  onProgress?.({ stage: 'complete', percent: 100 })
 }
 
 async function decryptFromLocalSingleFile({
@@ -444,7 +437,12 @@ async function decryptFromLocalSingleFile({
     }
 
     const encryptedBuffer = await fs.readFile(encryptedFilePath)
-    await writeDecryptedBuffer(encryptedBuffer, chunks, meta, tokenBytes, noncePrefix, outputPath, onProgress, signal)
+    try {
+      await writeDecryptedBuffer(encryptedBuffer, chunks, meta, tokenBytes, noncePrefix, outputPath, onProgress, signal)
+    } catch (error) {
+      await cleanupPartialOutput(outputPath)
+      throw error
+    }
     return
   }
 
@@ -452,7 +450,12 @@ async function decryptFromLocalSingleFile({
 
   if (stat.size <= 64 * 1024 * 1024) {
     const encryptedBuffer = await fs.readFile(encryptedFilePath)
-    await writeDecryptedBuffer(encryptedBuffer, chunks, meta, tokenBytes, noncePrefix, outputPath, onProgress, signal)
+    try {
+      await writeDecryptedBuffer(encryptedBuffer, chunks, meta, tokenBytes, noncePrefix, outputPath, onProgress, signal)
+    } catch (error) {
+      await cleanupPartialOutput(outputPath)
+      throw error
+    }
     return
   }
 
@@ -484,14 +487,22 @@ async function decryptFromLocalSingleFile({
       await outputHandle.write(plainPart)
       offset += chunk.encryptedSize
       decryptedBytes += plainPart.length
-      onProgress?.(Math.round((decryptedBytes / meta.originalSize) * 100))
+      onProgress?.(decryptProgress({
+        stage: 'decrypting',
+        part: chunk.chunkIndex + 1,
+        totalParts: chunks.length,
+        percent: Math.round((decryptedBytes / meta.originalSize) * 100),
+      }))
     }
+  } catch (error) {
+    await cleanupPartialOutput(outputPath)
+    throw error
   } finally {
     await fileHandle.close()
     await outputHandle.close()
   }
 
-  onProgress?.(100)
+  onProgress?.({ stage: 'complete', percent: 100 })
 }
 
 async function listLocalPartFiles(dirPath) {
@@ -554,13 +565,21 @@ async function decryptFromLocalParts({
 
       await fileHandle.write(plainPart)
       decryptedBytes += plainPart.length
-      onProgress?.(Math.round((decryptedBytes / meta.originalSize) * 100))
+      onProgress?.(decryptProgress({
+        stage: 'decrypting',
+        part: partNumber,
+        totalParts: chunks.length,
+        percent: Math.round((decryptedBytes / meta.originalSize) * 100),
+      }))
     }
+  } catch (error) {
+    await cleanupPartialOutput(outputPath)
+    throw error
   } finally {
     await fileHandle.close()
   }
 
-  onProgress?.(100)
+  onProgress?.({ stage: 'complete', percent: 100 })
 }
 
 function hintTokenConfusion(encryptionToken, linkToken) {
@@ -662,6 +681,20 @@ function buildDecryptResult({
   }
 }
 
+async function ensureOutputPath(outputPath, force) {
+  try {
+    await fs.access(outputPath)
+    if (!force) {
+      throw new Error(`Output file already exists: ${outputPath} (use --force to overwrite)`)
+    }
+    await fs.unlink(outputPath)
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error
+    }
+  }
+}
+
 async function decryptLocalFile(inputPath, options = {}) {
   const resolvedOptions = await applyUploadJsonDefaults(options)
   const absolutePath = path.resolve(inputPath)
@@ -681,15 +714,17 @@ async function decryptLocalFile(inputPath, options = {}) {
     hintTokenConfusion(resolvedOptions.encryptionToken, '')
   }
 
+  const hasCompleteLocalMeta = Boolean(resolvedOptions.inlineMeta || resolvedOptions.metaPath)
+
   const resolved = await resolveEncryptionMeta({
     metaPath: resolvedOptions.metaPath,
     inlineMeta: resolvedOptions.inlineMeta,
-    linkToken,
+    linkToken: hasCompleteLocalMeta ? '' : linkToken,
     baseUrl: resolvedOptions.baseUrl || shareReference.baseUrl,
     signal: resolvedOptions.signal,
     onStatus: resolvedOptions.onStatus,
   })
-  const meta = resolved.meta || resolved
+  const meta = resolved.meta
   const linkInfo = resolved.linkInfo || null
   const encryptionToken = resolveEncryptionToken(
     resolvedOptions.encryptionToken,
@@ -705,6 +740,7 @@ async function decryptLocalFile(inputPath, options = {}) {
   )
 
   await fs.mkdir(path.dirname(outputPath), { recursive: true })
+  await ensureOutputPath(outputPath, resolvedOptions.force)
 
   if (stat.isDirectory()) {
     await decryptFromLocalParts({
@@ -762,7 +798,10 @@ export async function decryptFile(input, options = {}) {
     throw new Error('Missing share URL, link token, or encrypted file path.')
   }
 
-  if (resolvedOptions.localFile || (!looksLikeRemoteInput(trimmedInput) && await pathExists(trimmedInput))) {
+  const treatAsLocal = resolvedOptions.localFile
+    || (!looksLikeRemoteInput(trimmedInput) && await pathExists(trimmedInput))
+
+  if (treatAsLocal) {
     return decryptLocalFile(trimmedInput, {
       ...resolvedOptions,
       onProgress: reportStatus,
@@ -785,7 +824,13 @@ export async function decryptFile(input, options = {}) {
     throw new Error('This link is not an encrypted file.')
   }
 
-  const meta = normalizeClientEncryptionMeta(linkInfo.clientEncryptionMeta)
+  let meta = resolvedOptions.inlineMeta
+  if (!meta && resolvedOptions.metaPath) {
+    meta = await readMetaFile(resolvedOptions.metaPath)
+  }
+  if (!meta) {
+    meta = normalizeClientEncryptionMeta(linkInfo.clientEncryptionMeta)
+  }
   if (!meta) {
     throw new Error('Invalid encryption metadata for this file.')
   }
@@ -800,6 +845,7 @@ export async function decryptFile(input, options = {}) {
   )
 
   await fs.mkdir(path.dirname(outputPath), { recursive: true })
+  await ensureOutputPath(outputPath, resolvedOptions.force)
 
   if (linkInfo.storageMode === 'parts') {
     await decryptFromParts({
@@ -812,6 +858,7 @@ export async function decryptFile(input, options = {}) {
       onProgress: reportStatus,
       onStatus: reportStatus,
       signal: resolvedOptions.signal,
+      concurrency: resolvedOptions.concurrency,
     })
   } else {
     const encryptedFileUrl = linkInfo.downloadUrl
@@ -826,6 +873,7 @@ export async function decryptFile(input, options = {}) {
       onProgress: reportStatus,
       onStatus: reportStatus,
       signal: resolvedOptions.signal,
+      baseUrl: parsed.baseUrl,
     })
   }
 

package/lib/progress.js

@@ -24,6 +24,48 @@ export function formatDuration(ms) {
   return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`
 }
 
+export function createProgressTracker({ totalBytes = null } = {}) {
+  let lastBytes = 0
+  let lastTime = Date.now()
+  let smoothedBytesPerSec = 0
+
+  return {
+    update(info = {}) {
+      const now = Date.now()
+      const bytes = Number(info.downloadedBytes ?? info.bytes ?? 0)
+      const elapsedMs = now - lastTime
+
+      if (elapsedMs >= 250 && bytes >= lastBytes) {
+        const instantRate = ((bytes - lastBytes) / elapsedMs) * 1000
+        smoothedBytesPerSec = smoothedBytesPerSec === 0
+          ? instantRate
+          : smoothedBytesPerSec * 0.7 + instantRate * 0.3
+        lastBytes = bytes
+        lastTime = now
+      }
+
+      const total = Number(info.totalBytes ?? totalBytes)
+      let etaMs = null
+
+      if (Number.isFinite(total) && total > bytes && smoothedBytesPerSec > 0) {
+        etaMs = Math.round(((total - bytes) / smoothedBytesPerSec) * 1000)
+      }
+
+      return {
+        ...info,
+        bytesPerSec: smoothedBytesPerSec > 0 ? smoothedBytesPerSec : undefined,
+        etaMs: etaMs ?? undefined,
+      }
+    },
+
+    reset() {
+      lastBytes = 0
+      lastTime = Date.now()
+      smoothedBytesPerSec = 0
+    },
+  }
+}
+
 export function formatProgressLine(info) {
   if (typeof info === 'number') {
     return `${info}%`
@@ -55,6 +97,14 @@ export function formatProgressLine(info) {
     segments.push(`${formatBytes(info.downloadedBytes)}/${formatBytes(info.totalBytes)}`)
   }
 
+  if (Number.isFinite(info.bytesPerSec) && info.bytesPerSec > 0) {
+    segments.push(`${formatBytes(info.bytesPerSec)}/s`)
+  }
+
+  if (Number.isFinite(info.etaMs) && info.etaMs > 0) {
+    segments.push(`ETA ${formatDuration(info.etaMs)}`)
+  }
+
   if (Number.isFinite(info.percent)) {
     segments.push(`${info.percent}%`)
   }