bytifi 0.2.5 → 0.2.7

package/lib/upload.js

@@ -1,222 +1,20 @@
+import fs from 'node:fs/promises'
+import {
+  apiFetchWithRetry,
+  sleep,
+} from './api.js'
 import {
   MULTIPART_THRESHOLD_BYTES,
   encryptChunkFromFile,
   resolveUploadFile,
 } from './crypto.js'
-import { formatDuration } from './progress.js'
-import fs from 'node:fs/promises'
 
-const DEFAULT_BASE_URL = 'https://bytifi.com'
 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, retryAfterMs = null } = {}) {
-    super(message)
-    this.name = 'BytifiApiError'
-    this.status = status
-    this.body = body
-    this.retryAfterMs = retryAfterMs
-  }
-}
-
-export class BytifiNetworkError extends Error {
-  constructor(message, { cause } = {}) {
-    super(message)
-    this.name = 'BytifiNetworkError'
-    this.cause = cause
-  }
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-function normalizeBaseUrl(baseUrl) {
-  return String(baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '')
-}
-
-function isRetryableError(error) {
-  if (error instanceof BytifiNetworkError) return true
-  if (error instanceof BytifiApiError) {
-    return error.status === 429 || error.status >= 500
-  }
-  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
-
-  try {
-    return JSON.parse(text)
-  } catch {
-    return text
-  }
-}
-
-async function apiFetch(baseUrl, path, { apiKey, method = 'GET', headers = {}, body = null, signal, binary = false } = {}) {
-  const url = `${normalizeBaseUrl(baseUrl)}${path}`
-  const requestHeaders = {
-    ...headers,
-  }
-
-  if (apiKey) {
-    requestHeaders.Authorization = `Bearer ${apiKey}`
-  }
-
-  let response
-
-  try {
-    response = await fetch(url, {
-      method,
-      headers: requestHeaders,
-      body,
-      signal,
-    })
-  } catch (error) {
-    if (signal?.aborted) {
-      throw new Error('Upload aborted.')
-    }
-    throw new BytifiNetworkError(error.message || 'Network request failed.', { cause: error })
-  }
-
-  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,
-      retryAfterMs: response.status === 429 ? parseRetryAfterMs(response) : null,
-    })
-  }
-
-  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,
-    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)
-
-  while (true) {
-    try {
-      return await apiFetch(baseUrl, path, { ...fetchOptions, signal })
-    } catch (error) {
-      if (signal?.aborted || error.message === 'Upload aborted.' || error.message === 'Decrypt aborted.') {
-        throw error
-      }
-
-      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
-      }
-
-      attempt += 1
-      await sleep(Math.min(1000 * (2 ** attempt), 8000))
-    }
-  }
-}
-
-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,
-  })
-}
+export { BytifiApiError, BytifiNetworkError, fetchPublicBinaryWithRetry, publicFetchWithRetry } from './api.js'
 
 function buildShareUrl(payload, encryptionToken) {
   return `${payload.url}#token=${encodeURIComponent(encryptionToken)}`
@@ -239,6 +37,11 @@ function buildResult(payload, context, shareUrl) {
   }
 }
 
+function uploadProgressPercent(completedParts, inFlightParts, totalParts) {
+  const weighted = completedParts + inFlightParts * 0.5
+  return Math.min(100, Math.round((weighted / totalParts) * 100))
+}
+
 async function collectEncryptedBuffer(filePath, context, { onProgress, signal } = {}) {
   const fileHandle = await fs.open(filePath, 'r')
   const encryptedParts = []
@@ -257,6 +60,11 @@ async function collectEncryptedBuffer(filePath, context, { onProgress, signal }
       })
 
       encryptedParts.push(await encryptChunkFromFile(fileHandle, chunkIndex, context))
+
+      if (signal?.aborted) {
+        throw new Error('Upload aborted.')
+      }
+
       onProgress?.({
         stage: 'encrypted',
         part: chunkIndex + 1,
@@ -353,6 +161,17 @@ function resolveUploadConcurrency(originalSize, requested) {
   return DEFAULT_CONCURRENCY
 }
 
+async function abortUploadSession(baseUrl, sessionToken, { apiKey, signal }) {
+  await apiFetchWithRetry(baseUrl, '/api/public/upload/abort', {
+    apiKey,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ sessionToken }),
+    signal,
+    retries: 1,
+  }).catch(() => {})
+}
+
 async function uploadMultipartStreaming(filePath, context, {
   apiKey,
   baseUrl,
@@ -397,8 +216,20 @@ async function uploadMultipartStreaming(filePath, context, {
     context.chunkCount,
   )
   const fileHandle = await fs.open(filePath, 'r')
+  const workerAbort = new AbortController()
   let nextChunkIndex = 0
   let completedParts = 0
+  let inFlightParts = 0
+  let sessionAborted = false
+
+  const combinedSignal = AbortSignal.any?.([signal, workerAbort.signal])
+    ?? (() => {
+      const controller = new AbortController()
+      const abort = () => controller.abort()
+      signal?.addEventListener('abort', abort, { once: true })
+      workerAbort.signal.addEventListener('abort', abort, { once: true })
+      return controller.signal
+    })()
 
   onProgress?.({
     stage: 'uploading',
@@ -406,6 +237,16 @@ async function uploadMultipartStreaming(filePath, context, {
     detail: `${workerCount} workers · session ${sessionToken.slice(0, 8)}…`,
   })
 
+  function reportPartProgress(stage, partNumber, partBytes) {
+    onProgress?.({
+      stage,
+      part: partNumber,
+      totalParts: context.chunkCount,
+      partBytes,
+      percent: uploadProgressPercent(completedParts, inFlightParts, context.chunkCount),
+    })
+  }
+
   function claimChunkIndex() {
     const chunkIndex = nextChunkIndex
     nextChunkIndex += 1
@@ -414,7 +255,7 @@ async function uploadMultipartStreaming(filePath, context, {
 
   async function pipelineWorker() {
     while (true) {
-      if (signal?.aborted) {
+      if (combinedSignal.aborted) {
         throw new Error('Upload aborted.')
       }
 
@@ -424,61 +265,60 @@ async function uploadMultipartStreaming(filePath, context, {
       }
 
       const partNumber = chunkIndex + 1
+      inFlightParts += 1
 
-      onProgress?.({
-        stage: 'encrypting',
-        part: partNumber,
-        totalParts: context.chunkCount,
-        percent: Math.round((completedParts / context.chunkCount) * 100),
-      })
+      try {
+        reportPartProgress('encrypting', partNumber)
 
-      const encryptedPart = await encryptChunkFromFile(fileHandle, chunkIndex, context)
+        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),
-      })
+        if (combinedSignal.aborted) {
+          throw new Error('Upload aborted.')
+        }
 
-      await apiFetchWithRetry(
-        baseUrl,
-        `/api/public/upload/part?sessionToken=${encodeURIComponent(sessionToken)}&partNumber=${partNumber}`,
-        {
-          apiKey,
-          method: 'PUT',
-          headers: { 'Content-Type': 'application/octet-stream' },
-          body: encryptedPart,
-          signal,
-          onStatus,
-          rateLimitRetries: UNLIMITED_RATE_LIMIT_RETRIES,
-        },
-      )
-
-      completedParts += 1
-      onProgress?.({
-        stage: 'uploaded',
-        part: partNumber,
-        totalParts: context.chunkCount,
-        partBytes: encryptedPart.length,
-        percent: Math.round((completedParts / context.chunkCount) * 100),
-        detail: `${completedParts}/${context.chunkCount} parts done`,
-      })
+        reportPartProgress('uploading', partNumber, encryptedPart.length)
+
+        await apiFetchWithRetry(
+          baseUrl,
+          `/api/public/upload/part?sessionToken=${encodeURIComponent(sessionToken)}&partNumber=${partNumber}`,
+          {
+            apiKey,
+            method: 'PUT',
+            headers: {
+              'Content-Type': 'application/octet-stream',
+              'X-Upload-Session': sessionToken,
+            },
+            body: encryptedPart,
+            signal: combinedSignal,
+            onStatus,
+            rateLimitRetries: UNLIMITED_RATE_LIMIT_RETRIES,
+            maxRateLimitWaitMs: 15_000,
+          },
+        )
+
+        completedParts += 1
+        onProgress?.({
+          stage: 'uploaded',
+          part: partNumber,
+          totalParts: context.chunkCount,
+          partBytes: encryptedPart.length,
+          percent: uploadProgressPercent(completedParts, inFlightParts, context.chunkCount),
+          detail: `${completedParts}/${context.chunkCount} parts done`,
+        })
+      } finally {
+        inFlightParts -= 1
+      }
     }
   }
 
   try {
     await Promise.all(Array.from({ length: workerCount }, () => pipelineWorker()))
   } catch (error) {
-    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(() => {})
+    workerAbort.abort()
+
+    if (!sessionAborted) {
+      sessionAborted = true
+      await abortUploadSession(baseUrl, sessionToken, { apiKey, signal })
     }
 
     throw error

package/lib/url.js

@@ -0,0 +1,26 @@
+export const DEFAULT_BASE_URL = 'https://bytifi.com'
+
+export function normalizeBaseUrl(baseUrl) {
+  return String(baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '')
+}
+
+export function validateBaseUrl(url) {
+  const normalized = normalizeBaseUrl(url)
+
+  let parsed
+  try {
+    parsed = new URL(normalized)
+  } catch {
+    throw new Error(`Invalid base URL: ${url}`)
+  }
+
+  if (!['http:', 'https:'].includes(parsed.protocol)) {
+    throw new Error(`Invalid base URL protocol: ${parsed.protocol} (use http: or https:)`)
+  }
+
+  if (!parsed.hostname) {
+    throw new Error('Invalid base URL: missing hostname.')
+  }
+
+  return normalized
+}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "bytifi",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Official Bytifi CLI — encrypt, upload, and decrypt files from the terminal",
   "type": "module",
+  "author": "Bytifi",
   "bin": {
     "bytifi": "./bin/bytifi.js"
   },
@@ -14,10 +15,12 @@
     "node": ">=18"
   },
   "scripts": {
+    "test": "node --test test/*.test.js",
     "upload": "node bin/bytifi.js upload",
     "decrypt": "node bin/bytifi.js decrypt",
     "build:bundle": "node scripts/build-bundle.mjs",
-    "build:win": "npm run build:bundle && pkg dist/bytifi-bundle.cjs --targets node22-win-x64 --output dist/bytifi.exe --compress GZip --public --public-packages \"*\""
+    "build:win": "npm run build:bundle && pkg dist/bytifi-bundle.cjs --targets node22-win-x64 --output dist/bytifi.exe --compress GZip --public --public-packages \"*\"",
+    "prepublishOnly": "npm test"
   },
   "repository": {
     "type": "git",