bytifi 0.2.3 → 0.2.5

package/bin/bytifi.js

@@ -5,6 +5,7 @@ import path from 'node:path'
 import process from 'node:process'
 import { createRequire } from 'node:module'
 import { decryptFile } from '../lib/decrypt.js'
+import { formatProgressLine } from '../lib/progress.js'
 import { BytifiApiError, BytifiNetworkError, uploadFile } from '../lib/upload.js'
 
 const require = createRequire(import.meta.url)
@@ -287,8 +288,15 @@ function validateExpires(minutes) {
   }
 }
 
-function writeProgress(label, percent) {
-  process.stderr.write(`\r${label}: ${percent}%`)
+function writeProgress(info) {
+  const line = formatProgressLine(info)
+  if (line) {
+    process.stderr.write(`\r${line}`)
+  }
+}
+
+function finishProgressLine() {
+  process.stderr.write('\n')
 }
 
 function clearProgressLine() {
@@ -320,7 +328,7 @@ async function runUpload(filePath, options) {
   process.on('SIGTERM', handleSignal)
 
   const showProgress = !options.quiet && !options.json
-  let lastPercent = -1
+  let lastLine = ''
 
   try {
     const result = await uploadFile(resolvedPath, {
@@ -332,17 +340,18 @@ async function runUpload(filePath, options) {
       concurrency: options.concurrency,
       signal: abortController.signal,
       onProgress: showProgress
-        ? (percent) => {
-            if (percent !== lastPercent) {
-              lastPercent = percent
-              writeProgress('Encrypting and uploading', percent)
+        ? (info) => {
+            const line = formatProgressLine(info)
+            if (line && line !== lastLine) {
+              lastLine = line
+              writeProgress(info)
             }
           }
         : undefined,
     })
 
     if (showProgress) {
-      clearProgressLine()
+      finishProgressLine()
     }
 
     if (options.json) {
@@ -375,7 +384,7 @@ async function runDecrypt(input, options) {
   process.on('SIGTERM', handleSignal)
 
   const showProgress = !options.quiet && !options.json
-  let lastPercent = -1
+  let lastLine = ''
 
   try {
     const result = await decryptFile(input, {
@@ -389,17 +398,18 @@ async function runDecrypt(input, options) {
       baseUrl: options.baseUrl,
       signal: abortController.signal,
       onProgress: showProgress
-        ? (percent) => {
-            if (percent !== lastPercent) {
-              lastPercent = percent
-              writeProgress('Downloading and decrypting', percent)
+        ? (info) => {
+            const line = formatProgressLine(info)
+            if (line && line !== lastLine) {
+              lastLine = line
+              writeProgress(info)
             }
           }
         : undefined,
     })
 
     if (showProgress) {
-      clearProgressLine()
+      finishProgressLine()
     }
 
     if (options.json) {
@@ -531,6 +541,7 @@ async function main() {
 
 main().catch((error) => {
   clearProgressLine()
+  finishProgressLine()
   const verbose = process.argv.includes('--verbose')
   printError(error, verbose)
   process.exit(exitCodeForError(error))

package/lib/decrypt.js

@@ -9,7 +9,7 @@ import {
   usesChunkCompression,
 } from './crypto.js'
 import { fromBase64Url } from './base64url.js'
-import { BytifiApiError, BytifiNetworkError } from './upload.js'
+import { BytifiApiError, fetchPublicBinaryWithRetry, publicFetchWithRetry } from './upload.js'
 
 const DEFAULT_BASE_URL = 'https://bytifi.com'
 
@@ -17,45 +17,6 @@ function normalizeBaseUrl(baseUrl) {
   return String(baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '')
 }
 
-async function readResponseBody(response) {
-  const text = await response.text()
-  if (!text) return null
-
-  try {
-    return JSON.parse(text)
-  } catch {
-    return text
-  }
-}
-
-async function publicFetch(baseUrl, requestPath, { signal } = {}) {
-  const url = `${normalizeBaseUrl(baseUrl)}${requestPath}`
-
-  let response
-
-  try {
-    response = await fetch(url, { signal })
-  } catch (error) {
-    if (signal?.aborted) {
-      throw new Error('Decrypt aborted.')
-    }
-    throw new BytifiNetworkError(error.message || 'Network request failed.', { cause: error })
-  }
-
-  const payload = await readResponseBody(response)
-
-  if (!response.ok) {
-    const message = typeof payload === 'object' && payload?.error
-      ? payload.error
-      : typeof payload === 'string' && payload
-        ? payload
-        : `Request failed with status ${response.status}.`
-    throw new BytifiApiError(message, { status: response.status, body: payload })
-  }
-
-  return payload
-}
-
 export function parseDecryptInput(input, { encryptionToken = '', baseUrl = DEFAULT_BASE_URL } = {}) {
   const trimmed = String(input || '').trim()
   if (!trimmed) {
@@ -168,6 +129,7 @@ async function resolveEncryptionMeta({
   linkToken = '',
   baseUrl = DEFAULT_BASE_URL,
   signal,
+  onStatus,
 }) {
   if (inlineMeta) {
     return { meta: inlineMeta }
@@ -184,7 +146,7 @@ async function resolveEncryptionMeta({
     )
   }
 
-  const linkInfo = await fetchLinkInfo(baseUrl, linkToken, signal)
+  const linkInfo = await fetchLinkInfo(baseUrl, linkToken, signal, onStatus)
 
   if (linkInfo.status === 'expired') {
     throw new Error('This file link has expired.')
@@ -207,25 +169,16 @@ function sanitizeOutputName(filename) {
   return base || 'download'
 }
 
-async function fetchLinkInfo(baseUrl, linkToken, signal) {
-  return publicFetch(baseUrl, `/api/link/${encodeURIComponent(linkToken)}`, { signal })
+async function fetchLinkInfo(baseUrl, linkToken, signal, onStatus) {
+  return publicFetchWithRetry(baseUrl, `/api/link/${encodeURIComponent(linkToken)}`, { signal, onStatus })
 }
 
-async function fetchEncryptedPart(baseUrl, linkToken, partNumber, signal) {
-  const response = await fetch(
-    `${normalizeBaseUrl(baseUrl)}/f/${encodeURIComponent(linkToken)}/p/${partNumber}`,
-    { signal },
+async function fetchEncryptedPart(baseUrl, linkToken, partNumber, signal, onStatus) {
+  return fetchPublicBinaryWithRetry(
+    baseUrl,
+    `/f/${encodeURIComponent(linkToken)}/p/${partNumber}`,
+    { signal, onStatus },
   )
-
-  if (!response.ok) {
-    const text = await response.text()
-    throw new BytifiApiError(text || `Failed to download part ${partNumber}.`, {
-      status: response.status,
-      body: text,
-    })
-  }
-
-  return Buffer.from(await response.arrayBuffer())
 }
 
 async function decryptFromParts({
@@ -236,6 +189,7 @@ async function decryptFromParts({
   noncePrefix,
   outputPath,
   onProgress,
+  onStatus,
   signal,
 }) {
   const { chunks } = buildEncryptedChunkPlan(meta)
@@ -249,7 +203,27 @@ async function decryptFromParts({
       }
 
       const chunk = chunks[index]
-      const encryptedPart = await fetchEncryptedPart(baseUrl, linkToken, chunk.chunkIndex + 1, signal)
+      const partNumber = chunk.chunkIndex + 1
+
+      onProgress?.({
+        stage: 'downloading',
+        part: partNumber,
+        totalParts: chunks.length,
+        downloadedBytes: decryptedBytes,
+        totalBytes: meta.originalSize,
+        percent: Math.round((decryptedBytes / meta.originalSize) * 100),
+      })
+
+      const encryptedPart = await fetchEncryptedPart(baseUrl, linkToken, partNumber, signal, onStatus)
+
+      onProgress?.({
+        stage: 'decrypting',
+        part: partNumber,
+        totalParts: chunks.length,
+        partBytes: encryptedPart.length,
+        percent: Math.round((decryptedBytes / meta.originalSize) * 100),
+      })
+
       const plainPart = await decryptPlainChunkFromEncrypted(
         encryptedPart,
         tokenBytes,
@@ -260,11 +234,22 @@ async function decryptFromParts({
 
       await fileHandle.write(plainPart)
       decryptedBytes += plainPart.length
-      onProgress?.(Math.round((decryptedBytes / meta.originalSize) * 100))
+
+      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`,
+      })
     }
   } finally {
     await fileHandle.close()
   }
+
+  onProgress?.({ stage: 'complete', percent: 100 })
 }
 
 async function decryptFromSingleFile({
@@ -702,6 +687,7 @@ async function decryptLocalFile(inputPath, options = {}) {
     linkToken,
     baseUrl: resolvedOptions.baseUrl || shareReference.baseUrl,
     signal: resolvedOptions.signal,
+    onStatus: resolvedOptions.onStatus,
   })
   const meta = resolved.meta || resolved
   const linkInfo = resolved.linkInfo || null
@@ -767,13 +753,21 @@ async function decryptLocalFile(inputPath, options = {}) {
 
 export async function decryptFile(input, options = {}) {
   const resolvedOptions = await applyUploadJsonDefaults(options)
+  const reportStatus = (info) => {
+    resolvedOptions.onStatus?.(info)
+    resolvedOptions.onProgress?.(info)
+  }
   const trimmedInput = String(input || '').trim()
   if (!trimmedInput) {
     throw new Error('Missing share URL, link token, or encrypted file path.')
   }
 
   if (resolvedOptions.localFile || (!looksLikeRemoteInput(trimmedInput) && await pathExists(trimmedInput))) {
-    return decryptLocalFile(trimmedInput, resolvedOptions)
+    return decryptLocalFile(trimmedInput, {
+      ...resolvedOptions,
+      onProgress: reportStatus,
+      onStatus: reportStatus,
+    })
   }
 
   const parsed = parseDecryptInput(trimmedInput, {
@@ -781,7 +775,7 @@ export async function decryptFile(input, options = {}) {
     baseUrl: resolvedOptions.baseUrl,
   })
 
-  const linkInfo = await fetchLinkInfo(parsed.baseUrl, parsed.linkToken, resolvedOptions.signal)
+  const linkInfo = await fetchLinkInfo(parsed.baseUrl, parsed.linkToken, resolvedOptions.signal, reportStatus)
 
   if (linkInfo.status === 'expired') {
     throw new Error('This file link has expired.')
@@ -815,7 +809,8 @@ export async function decryptFile(input, options = {}) {
       tokenBytes,
       noncePrefix,
       outputPath,
-      onProgress: resolvedOptions.onProgress,
+      onProgress: reportStatus,
+      onStatus: reportStatus,
       signal: resolvedOptions.signal,
     })
   } else {
@@ -828,7 +823,8 @@ export async function decryptFile(input, options = {}) {
       tokenBytes,
       noncePrefix,
       outputPath,
-      onProgress: resolvedOptions.onProgress,
+      onProgress: reportStatus,
+      onStatus: reportStatus,
       signal: resolvedOptions.signal,
     })
   }

package/lib/progress.js

@@ -0,0 +1,67 @@
+export function formatBytes(bytes) {
+  const value = Number(bytes)
+  if (!Number.isFinite(value) || value < 0) return '0 B'
+
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  let size = value
+  let unitIndex = 0
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024
+    unitIndex += 1
+  }
+
+  const digits = size >= 100 || unitIndex === 0 ? 0 : size >= 10 ? 1 : 2
+  return `${size.toFixed(digits)} ${units[unitIndex]}`
+}
+
+export function formatDuration(ms) {
+  const totalSeconds = Math.max(1, Math.ceil(Number(ms) / 1000))
+  if (totalSeconds < 60) return `${totalSeconds}s`
+
+  const minutes = Math.floor(totalSeconds / 60)
+  const seconds = totalSeconds % 60
+  return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`
+}
+
+export function formatProgressLine(info) {
+  if (typeof info === 'number') {
+    return `${info}%`
+  }
+
+  if (!info || typeof info !== 'object') {
+    return ''
+  }
+
+  if (info.stage === 'waiting') {
+    return info.message || 'Waiting…'
+  }
+
+  const segments = []
+
+  if (info.part && info.totalParts) {
+    segments.push(`part ${info.part}/${info.totalParts}`)
+  }
+
+  if (info.stage) {
+    segments.push(info.stage)
+  }
+
+  if (info.partBytes) {
+    segments.push(formatBytes(info.partBytes))
+  }
+
+  if (Number.isFinite(info.downloadedBytes) && Number.isFinite(info.totalBytes)) {
+    segments.push(`${formatBytes(info.downloadedBytes)}/${formatBytes(info.totalBytes)}`)
+  }
+
+  if (Number.isFinite(info.percent)) {
+    segments.push(`${info.percent}%`)
+  }
+
+  if (info.detail) {
+    segments.push(info.detail)
+  }
+
+  return segments.join(' · ')
+}

package/lib/upload.js

@@ -3,6 +3,7 @@ import {
   encryptChunkFromFile,
   resolveUploadFile,
 } from './crypto.js'
+import { formatDuration } from './progress.js'
 import fs from 'node:fs/promises'
 
 const DEFAULT_BASE_URL = 'https://bytifi.com'
@@ -10,13 +11,15 @@ const DEFAULT_CONCURRENCY = 4
 const POLL_INTERVAL_MS = 1500
 const POLL_TIMEOUT_MS = 30 * 60 * 1000
 const MAX_RETRIES = 3
+const UNLIMITED_RATE_LIMIT_RETRIES = Number.POSITIVE_INFINITY
 
 export class BytifiApiError extends Error {
-  constructor(message, { status = 0, body = null } = {}) {
+  constructor(message, { status = 0, body = null, retryAfterMs = null } = {}) {
     super(message)
     this.name = 'BytifiApiError'
     this.status = status
     this.body = body
+    this.retryAfterMs = retryAfterMs
   }
 }
 
@@ -44,6 +47,34 @@ function isRetryableError(error) {
   return false
 }
 
+function parseRetryAfterMs(response) {
+  const retryAfter = response.headers.get('Retry-After')
+  if (retryAfter) {
+    const seconds = Number(retryAfter)
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return seconds * 1000
+    }
+
+    const dateMs = Date.parse(retryAfter)
+    if (Number.isFinite(dateMs)) {
+      return Math.max(0, dateMs - Date.now())
+    }
+  }
+
+  const resetHeader = response.headers.get('RateLimit-Reset')
+  if (resetHeader) {
+    const resetValue = Number(resetHeader)
+    if (Number.isFinite(resetValue)) {
+      if (resetValue > 1_000_000_000) {
+        return Math.max(0, resetValue * 1000 - Date.now())
+      }
+      return Math.max(0, resetValue * 1000)
+    }
+  }
+
+  return null
+}
+
 async function readResponseBody(response) {
   const text = await response.text()
   if (!text) return null
@@ -55,13 +86,16 @@ async function readResponseBody(response) {
   }
 }
 
-async function apiFetch(baseUrl, path, { apiKey, method = 'GET', headers = {}, body = null, signal } = {}) {
+async function apiFetch(baseUrl, path, { apiKey, method = 'GET', headers = {}, body = null, signal, binary = false } = {}) {
   const url = `${normalizeBaseUrl(baseUrl)}${path}`
   const requestHeaders = {
-    Authorization: `Bearer ${apiKey}`,
     ...headers,
   }
 
+  if (apiKey) {
+    requestHeaders.Authorization = `Bearer ${apiKey}`
+  }
+
   let response
 
   try {
@@ -78,41 +112,110 @@ async function apiFetch(baseUrl, path, { apiKey, method = 'GET', headers = {}, b
     throw new BytifiNetworkError(error.message || 'Network request failed.', { cause: error })
   }
 
-  const payload = await readResponseBody(response)
+  const responseBuffer = Buffer.from(await response.arrayBuffer())
 
   if (!response.ok) {
+    const text = responseBuffer.toString('utf8')
+    let payload = text
+    try {
+      payload = JSON.parse(text)
+    } catch {
+      // keep text
+    }
+
     const message = typeof payload === 'object' && payload?.error
       ? payload.error
       : typeof payload === 'string' && payload
         ? payload
         : `Request failed with status ${response.status}.`
-    throw new BytifiApiError(message, { status: response.status, body: payload })
+    throw new BytifiApiError(message, {
+      status: response.status,
+      body: payload,
+      retryAfterMs: response.status === 429 ? parseRetryAfterMs(response) : null,
+    })
   }
 
-  return payload
+  if (binary) {
+    return responseBuffer
+  }
+
+  const text = responseBuffer.toString('utf8')
+  if (!text) return null
+
+  try {
+    return JSON.parse(text)
+  } catch {
+    return text
+  }
 }
 
 async function apiFetchWithRetry(baseUrl, path, options = {}) {
-  const { retries = MAX_RETRIES, signal } = options
+  const {
+    retries = MAX_RETRIES,
+    rateLimitRetries = 0,
+    onStatus,
+    signal,
+    ...fetchOptions
+  } = options
+
+  let attempt = 0
+  let rateLimitAttempt = 0
+  const maxRateLimitRetries = rateLimitRetries === UNLIMITED_RATE_LIMIT_RETRIES
+    ? UNLIMITED_RATE_LIMIT_RETRIES
+    : (rateLimitRetries || retries)
 
-  for (let attempt = 0; attempt <= retries; attempt += 1) {
+  while (true) {
     try {
-      return await apiFetch(baseUrl, path, options)
+      return await apiFetch(baseUrl, path, { ...fetchOptions, signal })
     } catch (error) {
-      if (signal?.aborted || error.message === 'Upload aborted.') {
+      if (signal?.aborted || error.message === 'Upload aborted.' || error.message === 'Decrypt aborted.') {
         throw error
       }
 
-      if (!isRetryableError(error) || attempt === retries) {
+      if (error instanceof BytifiApiError && error.status === 429) {
+        if (rateLimitAttempt >= maxRateLimitRetries) {
+          throw error
+        }
+
+        rateLimitAttempt += 1
+        const waitMs = error.retryAfterMs ?? Math.min(600_000, 15_000 * rateLimitAttempt)
+
+        onStatus?.({
+          stage: 'waiting',
+          message: `Rate limited — waiting ${formatDuration(waitMs)} before retry (${rateLimitAttempt})…`,
+          waitMs,
+          retryAttempt: rateLimitAttempt,
+        })
+
+        await sleep(waitMs)
+        continue
+      }
+
+      if (!isRetryableError(error) || attempt >= retries) {
         throw error
       }
 
-      const delayMs = Math.min(1000 * (2 ** attempt), 8000)
-      await sleep(delayMs)
+      attempt += 1
+      await sleep(Math.min(1000 * (2 ** attempt), 8000))
     }
   }
+}
 
-  throw new Error('Request failed after retries.')
+export async function publicFetchWithRetry(baseUrl, path, options = {}) {
+  return apiFetchWithRetry(baseUrl, path, {
+    ...options,
+    apiKey: null,
+    rateLimitRetries: options.rateLimitRetries ?? UNLIMITED_RATE_LIMIT_RETRIES,
+  })
+}
+
+export async function fetchPublicBinaryWithRetry(baseUrl, path, options = {}) {
+  return apiFetchWithRetry(baseUrl, path, {
+    ...options,
+    apiKey: null,
+    binary: true,
+    rateLimitRetries: options.rateLimitRetries ?? UNLIMITED_RATE_LIMIT_RETRIES,
+  })
 }
 
 function buildShareUrl(payload, encryptionToken) {
@@ -136,69 +239,6 @@ function buildResult(payload, context, shareUrl) {
   }
 }
 
-function createBoundedQueue(maxSize) {
-  const items = []
-  const waiters = []
-  let closed = false
-
-  function notifyWaiters() {
-    while (waiters.length > 0) {
-      const resolve = waiters.shift()
-      resolve()
-    }
-  }
-
-  return {
-    async push(item, signal) {
-      while (items.length >= maxSize) {
-        if (signal?.aborted) {
-          throw new Error('Upload aborted.')
-        }
-        await new Promise((resolve, reject) => {
-          const onAbort = () => {
-            const index = waiters.indexOf(resolve)
-            if (index >= 0) waiters.splice(index, 1)
-            reject(new Error('Upload aborted.'))
-          }
-          waiters.push(resolve)
-          signal?.addEventListener('abort', onAbort, { once: true })
-        })
-      }
-
-      items.push(item)
-      notifyWaiters()
-    },
-    async take(signal) {
-      while (items.length === 0) {
-        if (closed) {
-          return null
-        }
-        if (signal?.aborted) {
-          throw new Error('Upload aborted.')
-        }
-        await new Promise((resolve, reject) => {
-          const onAbort = () => {
-            const index = waiters.indexOf(resolve)
-            if (index >= 0) waiters.splice(index, 1)
-            reject(new Error('Upload aborted.'))
-          }
-          waiters.push(resolve)
-          signal?.addEventListener('abort', onAbort, { once: true })
-        })
-      }
-
-      return items.shift()
-    },
-    close() {
-      closed = true
-      notifyWaiters()
-    },
-    get pending() {
-      return items.length
-    },
-  }
-}
-
 async function collectEncryptedBuffer(filePath, context, { onProgress, signal } = {}) {
   const fileHandle = await fs.open(filePath, 'r')
   const encryptedParts = []
@@ -209,14 +249,26 @@ async function collectEncryptedBuffer(filePath, context, { onProgress, signal }
         throw new Error('Upload aborted.')
       }
 
+      onProgress?.({
+        stage: 'encrypting',
+        part: chunkIndex + 1,
+        totalParts: context.chunkCount,
+        percent: Math.round((chunkIndex / context.chunkCount) * 90),
+      })
+
       encryptedParts.push(await encryptChunkFromFile(fileHandle, chunkIndex, context))
-      onProgress?.(Math.round(((chunkIndex + 1) / context.chunkCount) * 90))
+      onProgress?.({
+        stage: 'encrypted',
+        part: chunkIndex + 1,
+        totalParts: context.chunkCount,
+        percent: Math.round(((chunkIndex + 1) / context.chunkCount) * 90),
+      })
     }
   } finally {
     await fileHandle.close()
   }
 
-  onProgress?.(95)
+  onProgress?.({ stage: 'uploading', percent: 95, detail: 'direct upload' })
   return Buffer.concat(encryptedParts)
 }
 
@@ -226,6 +278,7 @@ async function uploadDirect(context, encryptedBuffer, {
   expiresInMinutes,
   deleteOnDownload,
   onProgress,
+  onStatus,
   signal,
 }) {
   const formData = new FormData()
@@ -242,15 +295,17 @@ async function uploadDirect(context, encryptedBuffer, {
     method: 'POST',
     body: formData,
     signal,
+    onStatus,
+    rateLimitRetries: UNLIMITED_RATE_LIMIT_RETRIES,
   })
 
-  onProgress?.(100)
+  onProgress?.({ stage: 'complete', percent: 100 })
 
   const shareUrl = buildShareUrl(payload, context.token)
   return buildResult(payload, context, shareUrl)
 }
 
-async function pollUploadStatus(sessionToken, { apiKey, baseUrl, signal }) {
+async function pollUploadStatus(sessionToken, { apiKey, baseUrl, signal, onStatus }) {
   const startedAt = Date.now()
 
   while (true) {
@@ -265,27 +320,57 @@ async function pollUploadStatus(sessionToken, { apiKey, baseUrl, signal }) {
     const payload = await apiFetchWithRetry(
       baseUrl,
       `/api/public/upload/status?sessionToken=${encodeURIComponent(sessionToken)}`,
-      { apiKey, signal },
+      {
+        apiKey,
+        signal,
+        onStatus,
+        rateLimitRetries: UNLIMITED_RATE_LIMIT_RETRIES,
+      },
     )
 
     if (payload.status !== 'processing' && payload.status !== 'pending') {
       return payload
     }
 
+    onStatus?.({
+      stage: 'finalizing',
+      percent: Math.min(99, Math.round(Number(payload?.progress?.percent || 0))),
+      detail: payload?.progress?.phase || 'processing on server',
+    })
+
     await sleep(POLL_INTERVAL_MS)
   }
 }
 
+function resolveUploadConcurrency(originalSize, requested) {
+  const requestedValue = Number(requested)
+  if (Number.isFinite(requestedValue) && requestedValue > 0) {
+    return Math.min(16, Math.max(1, Math.floor(requestedValue)))
+  }
+
+  if (originalSize >= 3 * 1024 * 1024 * 1024) return 2
+  if (originalSize >= 1024 * 1024 * 1024) return 3
+  return DEFAULT_CONCURRENCY
+}
+
 async function uploadMultipartStreaming(filePath, context, {
   apiKey,
   baseUrl,
   expiresInMinutes,
   deleteOnDownload,
   onProgress,
+  onStatus,
   signal,
   concurrency = DEFAULT_CONCURRENCY,
 }) {
   const maxPartSize = context.meta.chunkSize + 16
+
+  onProgress?.({
+    stage: 'starting',
+    percent: 0,
+    detail: `${context.chunkCount} parts · ${context.compression === 'gzip' ? 'gzip' : 'raw'} chunks`,
+  })
+
   const initPayload = await apiFetchWithRetry(baseUrl, '/api/public/upload/init', {
     apiKey,
     method: 'POST',
@@ -302,25 +387,32 @@ async function uploadMultipartStreaming(filePath, context, {
       deleteOnDownload,
     }),
     signal,
+    onStatus,
+    rateLimitRetries: UNLIMITED_RATE_LIMIT_RETRIES,
   })
 
   const sessionToken = initPayload.sessionToken
   const workerCount = Math.min(
-    Number(concurrency) || Number(initPayload.concurrency) || DEFAULT_CONCURRENCY,
+    resolveUploadConcurrency(context.originalSize, concurrency || initPayload.concurrency),
     context.chunkCount,
   )
-  const queue = createBoundedQueue(Math.max(2, workerCount * 2))
   const fileHandle = await fs.open(filePath, 'r')
   let nextChunkIndex = 0
   let completedParts = 0
 
+  onProgress?.({
+    stage: 'uploading',
+    percent: 0,
+    detail: `${workerCount} workers · session ${sessionToken.slice(0, 8)}…`,
+  })
+
   function claimChunkIndex() {
     const chunkIndex = nextChunkIndex
     nextChunkIndex += 1
     return chunkIndex
   }
 
-  async function encryptWorker() {
+  async function pipelineWorker() {
     while (true) {
       if (signal?.aborted) {
         throw new Error('Upload aborted.')
@@ -331,74 +423,87 @@ async function uploadMultipartStreaming(filePath, context, {
         return
       }
 
-      const encryptedPart = await encryptChunkFromFile(fileHandle, chunkIndex, context)
-      await queue.push({
-        partNumber: chunkIndex + 1,
-        body: encryptedPart,
-      }, signal)
-    }
-  }
+      const partNumber = chunkIndex + 1
 
-  async function uploadWorker() {
-    while (true) {
-      if (signal?.aborted) {
-        throw new Error('Upload aborted.')
-      }
+      onProgress?.({
+        stage: 'encrypting',
+        part: partNumber,
+        totalParts: context.chunkCount,
+        percent: Math.round((completedParts / context.chunkCount) * 100),
+      })
 
-      const part = await queue.take(signal)
-      if (!part) {
-        return
-      }
+      const encryptedPart = await encryptChunkFromFile(fileHandle, chunkIndex, context)
+
+      onProgress?.({
+        stage: 'uploading',
+        part: partNumber,
+        totalParts: context.chunkCount,
+        partBytes: encryptedPart.length,
+        percent: Math.round((completedParts / context.chunkCount) * 100),
+      })
 
       await apiFetchWithRetry(
         baseUrl,
-        `/api/public/upload/part?sessionToken=${encodeURIComponent(sessionToken)}&partNumber=${part.partNumber}`,
+        `/api/public/upload/part?sessionToken=${encodeURIComponent(sessionToken)}&partNumber=${partNumber}`,
         {
           apiKey,
           method: 'PUT',
           headers: { 'Content-Type': 'application/octet-stream' },
-          body: part.body,
+          body: encryptedPart,
           signal,
+          onStatus,
+          rateLimitRetries: UNLIMITED_RATE_LIMIT_RETRIES,
         },
       )
 
       completedParts += 1
-      onProgress?.(Math.round((completedParts / context.chunkCount) * 100))
+      onProgress?.({
+        stage: 'uploaded',
+        part: partNumber,
+        totalParts: context.chunkCount,
+        partBytes: encryptedPart.length,
+        percent: Math.round((completedParts / context.chunkCount) * 100),
+        detail: `${completedParts}/${context.chunkCount} parts done`,
+      })
     }
   }
 
   try {
-    const uploadWorkers = Array.from({ length: workerCount }, () => uploadWorker())
-    const encryptWorkers = Array.from({ length: workerCount }, () => encryptWorker())
-    await Promise.all(encryptWorkers)
-    queue.close()
-    await Promise.all(uploadWorkers)
+    await Promise.all(Array.from({ length: workerCount }, () => pipelineWorker()))
   } catch (error) {
-    await apiFetchWithRetry(baseUrl, '/api/public/upload/abort', {
-      apiKey,
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ sessionToken }),
-      signal,
-    }).catch(() => {})
+    if (!(error instanceof BytifiApiError && error.status === 429)) {
+      await apiFetchWithRetry(baseUrl, '/api/public/upload/abort', {
+        apiKey,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sessionToken }),
+        signal,
+      }).catch(() => {})
+    }
 
     throw error
   } finally {
     await fileHandle.close()
   }
 
+  onProgress?.({ stage: 'finalizing', percent: 99, detail: 'completing upload session' })
+
   let completePayload = await apiFetchWithRetry(baseUrl, '/api/public/upload/complete', {
     apiKey,
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ sessionToken }),
     signal,
+    onStatus,
+    rateLimitRetries: UNLIMITED_RATE_LIMIT_RETRIES,
   })
 
   if (completePayload.status === 'processing' || completePayload.status === 'pending') {
-    completePayload = await pollUploadStatus(sessionToken, { apiKey, baseUrl, signal })
+    completePayload = await pollUploadStatus(sessionToken, { apiKey, baseUrl, signal, onStatus })
   }
 
+  onProgress?.({ stage: 'complete', percent: 100 })
+
   const shareUrl = buildShareUrl(completePayload, context.token)
   return buildResult(completePayload, context, shareUrl)
 }
@@ -408,18 +513,28 @@ export async function uploadFile(filePath, options) {
     throw new Error('API key is required.')
   }
 
+  const reportStatus = (info) => {
+    options.onStatus?.(info)
+    options.onProgress?.(info)
+  }
+
+  const uploadOptions = {
+    ...options,
+    onStatus: reportStatus,
+  }
+
   const { absolutePath, context } = await resolveUploadFile(filePath, {
     mimeType: options.mimeType,
   })
 
   if (context.originalSize <= MULTIPART_THRESHOLD_BYTES) {
     const encryptedBuffer = await collectEncryptedBuffer(absolutePath, context, {
-      onProgress: options.onProgress,
+      onProgress: reportStatus,
       signal: options.signal,
     })
 
-    return uploadDirect(context, encryptedBuffer, options)
+    return uploadDirect(context, encryptedBuffer, uploadOptions)
   }
 
-  return uploadMultipartStreaming(absolutePath, context, options)
+  return uploadMultipartStreaming(absolutePath, context, uploadOptions)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bytifi",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Official Bytifi CLI — encrypt, upload, and decrypt files from the terminal",
   "type": "module",
   "bin": {