bytifi 0.2.2 → 0.2.4

package/README.md

@@ -59,7 +59,7 @@ bytifi upload ./logs.txt --concurrency 8 --json > upload.json
 bytifi upload ./photo.png -q
 ```
 
-All uploads are gzip-compressed per chunk before encryption. Files over **10 MB** use multipart upload automatically.
+Files up to **10 MB** are gzip-compressed per chunk before encryption. Larger files use multipart upload with fixed-size encrypted parts (no compression — gzip can expand ISO/zip data past the server part limit).
 
 Upload accepts **one file at a time**. Quote paths that contain spaces. Avoid shell globs like `**` — your shell may expand them into dozens of paths.
 

package/bin/bytifi.js

@@ -291,6 +291,10 @@ function writeProgress(label, percent) {
   process.stderr.write(`\r${label}: ${percent}%`)
 }
 
+function finishProgressLine() {
+  process.stderr.write('\n')
+}
+
 function clearProgressLine() {
   process.stderr.write('\r\x1b[K')
 }
@@ -342,7 +346,7 @@ async function runUpload(filePath, options) {
     })
 
     if (showProgress) {
-      clearProgressLine()
+      finishProgressLine()
     }
 
     if (options.json) {
@@ -399,7 +403,7 @@ async function runDecrypt(input, options) {
     })
 
     if (showProgress) {
-      clearProgressLine()
+      finishProgressLine()
     }
 
     if (options.json) {
@@ -531,6 +535,7 @@ async function main() {
 
 main().catch((error) => {
   clearProgressLine()
+  finishProgressLine()
   const verbose = process.argv.includes('--verbose')
   printError(error, verbose)
   process.exit(exitCodeForError(error))

package/lib/crypto.js

@@ -20,7 +20,14 @@ export function buildChunkIv(noncePrefix, chunkIndex) {
   return iv
 }
 
-export function resolveCompressionMode() {
+export function resolveCompressionMode(originalSize = 0) {
+  // Multipart uploads use fixed 32 MB encrypted parts on the server. Gzip can
+  // expand incompressible data (ISO, zip, etc.) past that limit and fail part
+  // validation, so only gzip-compress direct uploads.
+  if (originalSize > MULTIPART_THRESHOLD_BYTES) {
+    return 'none'
+  }
+
   return 'gzip'
 }
 
@@ -63,11 +70,16 @@ export function buildClientEncryptionMeta({
   noncePrefix,
   originalSize,
   mimeType,
+  compression = 'gzip',
 }) {
+  const compressionMeta = compression === 'gzip'
+    ? { algorithm: 'gzip', scope: 'chunk' }
+    : { algorithm: 'none', scope: 'chunk' }
+
   return {
-    version: 2,
+    version: compression === 'gzip' ? 2 : 1,
     algorithm: 'AES-GCM',
-    compression: { algorithm: 'gzip', scope: 'chunk' },
+    compression: compressionMeta,
     chunkSize: plainChunkSize,
     chunkCount,
     noncePrefix: toBase64Url(noncePrefix),
@@ -100,6 +112,7 @@ export function createEncryptionContext({
   if (tokenBytes.length !== 32) throw new Error('Encryption token must be 32 bytes.')
   if (noncePrefix.length !== 8) throw new Error('Nonce prefix must be 8 bytes.')
 
+  const compression = resolveCompressionMode(originalSize)
   const { chunkCount, encryptedSize } = calculateEncryptedSize(originalSize, plainChunkSize)
   const meta = buildClientEncryptionMeta({
     plainChunkSize,
@@ -107,6 +120,7 @@ export function createEncryptionContext({
     noncePrefix,
     originalSize,
     mimeType,
+    compression,
   })
 
   return {
@@ -120,7 +134,7 @@ export function createEncryptionContext({
     mimeType,
     originalSize,
     plainChunkSize,
-    compression: 'gzip',
+    compression,
   }
 }
 
@@ -166,7 +180,10 @@ export async function encryptChunkFromFile(fileHandle, chunkIndex, context) {
     context.plainChunkSize,
   )
 
-  let payload = await compressPlainChunk(plainChunk)
+  let payload = plainChunk
+  if (context.compression === 'gzip') {
+    payload = await compressPlainChunk(plainChunk)
+  }
 
   return encryptChunk(payload, context.tokenBytes, context.noncePrefix, chunkIndex)
 }

package/lib/upload.js

@@ -136,69 +136,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 = []
@@ -276,6 +213,17 @@ async function pollUploadStatus(sessionToken, { apiKey, baseUrl, signal }) {
   }
 }
 
+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,
@@ -306,10 +254,9 @@ async function uploadMultipartStreaming(filePath, context, {
 
   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
@@ -320,7 +267,7 @@ async function uploadMultipartStreaming(filePath, context, {
     return chunkIndex
   }
 
-  async function encryptWorker() {
+  async function pipelineWorker() {
     while (true) {
       if (signal?.aborted) {
         throw new Error('Upload aborted.')
@@ -332,32 +279,15 @@ async function uploadMultipartStreaming(filePath, context, {
       }
 
       const encryptedPart = await encryptChunkFromFile(fileHandle, chunkIndex, context)
-      await queue.push({
-        partNumber: chunkIndex + 1,
-        body: encryptedPart,
-      }, signal)
-    }
-  }
-
-  async function uploadWorker() {
-    while (true) {
-      if (signal?.aborted) {
-        throw new Error('Upload aborted.')
-      }
-
-      const part = await queue.take(signal)
-      if (!part) {
-        return
-      }
 
       await apiFetchWithRetry(
         baseUrl,
-        `/api/public/upload/part?sessionToken=${encodeURIComponent(sessionToken)}&partNumber=${part.partNumber}`,
+        `/api/public/upload/part?sessionToken=${encodeURIComponent(sessionToken)}&partNumber=${chunkIndex + 1}`,
         {
           apiKey,
           method: 'PUT',
           headers: { 'Content-Type': 'application/octet-stream' },
-          body: part.body,
+          body: encryptedPart,
           signal,
         },
       )
@@ -368,11 +298,7 @@ async function uploadMultipartStreaming(filePath, context, {
   }
 
   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,

package/package.json

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