Update index.js

index.js

@@ -248,6 +248,23 @@ app.post('/upload', checkRAM, (req, res) => {
     let fileName = 'unknown';
     let mimeType = 'application/octet-stream';
 
+    // ── Telegram upload API thresholds ────────────────────────────────────
+    // Files <= SMALL_FILE_THRESHOLD  → SaveFilePart  + InputFile    (small-file API)
+    // Files >  SMALL_FILE_THRESHOLD  → SaveBigFilePart + InputFileBig (big-file API)
+    //
+    // Telegram enforces this split strictly:
+    //   • SaveBigFilePart rejects parts < 512 KB unless it's the very last part
+    //     of a >10 MB file.
+    //   • SaveFilePart has no minimum part size but is limited to files ≤ 10 MB.
+    //
+    // Since we don't always know the size upfront (streaming), we use
+    // declaredSize (x-file-size header) when available. If unknown we default
+    // to the big-file path (safe for all sizes) but only once we know the
+    // file is actually large. For truly unknown sizes we buffer up to
+    // SMALL_FILE_THRESHOLD + 1 byte: if the file fits, use small API; if not,
+    // switch to big-file streaming with the buffered bytes as the first parts.
+    const SMALL_FILE_THRESHOLD = 10 * 1024 * 1024; // 10 MB
+
     // ── Per-TG-document state ─────────────────────────────────────────────
     const finalDocs = [];
     let docIdx      = 0;
@@ -255,12 +272,14 @@ app.post('/upload', checkRAM, (req, res) => {
     let tgPartIdx   = 0;   // part index within current TG doc
     let tgFileId    = makeTgFileId(0);
     let totalBytes  = 0;
+    let isBigFile   = (declaredSize > SMALL_FILE_THRESHOLD); // resolved at stream-end if unknown
 
-    // Accumulation ring — drained only in exact PART_SIZE slices
-    const partChunks = [];   // Buffer[] pending
-    let   partLen    = 0;    // total bytes in partChunks
+    // Accumulation ring — drained only in exact PART_SIZE slices (big-file path)
+    // Also used as a full-file buffer on the small-file path.
+    const partChunks = [];
+    let   partLen    = 0;
 
-    // In-flight SaveBigFilePart promises
+    // In-flight SaveBigFilePart promises (big-file path only)
     const inFlight = [];
 
     async function flushInFlight() {
@@ -268,26 +287,69 @@ app.post('/upload', checkRAM, (req, res) => {
       await Promise.all(inFlight.splice(0));
     }
 
-    // Send one part (exactly PART_SIZE, or final smaller part).
-    // fileTotalParts is a running UPPER BOUND — Telegram only requires that
-    // (a) filePart < fileTotalParts on every call, and
-    // (b) InputFileBig.parts == the ACTUAL count at SendMedia time.
-    // We use declaredSize when available for a tight estimate; otherwise we
-    // fall back to PIECE_BYTES (the max a single TG doc can hold).
-    // The value is recalculated each call so it stays valid as tgPartIdx grows.
-    async function sendPart(buf, fileStream) {
-      const partNo = tgPartIdx++;
-
-      // Bytes remaining in this TG doc (conservative: use declared size if
-      // it fits in one doc, else use the full doc ceiling).
+    // ── Small-file path ───────────────────────────────────────────────────
+    // Called once, after the entire file has been buffered (≤ 10 MB).
+    // Uses SaveFilePart (no minimum part size) + InputFile.
+    async function uploadSmallFile(fullBuf, committedBytes) {
+      const SMALL_PART = 512 * 1024; // can use any size ≤ 512 KB; 512 KB is fine
+      const numParts   = Math.ceil(fullBuf.length / SMALL_PART);
+      const smallId    = tgFileId; // already a BigInt
+
+      for (let i = 0; i < numParts; i++) {
+        const slice = fullBuf.slice(i * SMALL_PART, (i + 1) * SMALL_PART);
+        await client.invoke(new Api.upload.SaveFilePart({
+          fileId:   smallId,
+          filePart: i,
+          bytes:    Buffer.isBuffer(slice) ? slice : Buffer.from(slice),
+        }));
+      }
+
+      const tgName = `${fileName}.part${docIdx + 1}`;
+      const sent   = await client.invoke(new Api.messages.SendMedia({
+        peer,
+        media: new Api.InputMediaUploadedDocument({
+          file: new Api.InputFile({   // ← InputFile, NOT InputFileBig
+            id:    smallId,
+            parts: numParts,
+            name:  tgName,
+            md5Checksum: '',
+          }),
+          mimeType:   mimeType || 'application/octet-stream',
+          forceFile:  true,
+          attributes: [new Api.DocumentAttributeFilename({ fileName: tgName })],
+        }),
+        message:  `\ud83d\udcc2 ${fileName} | Part ${docIdx + 1}`,
+        randomId: BigInt(Date.now()) + BigInt(Math.floor(Math.random() * 1e9)),
+      }));
+
+      const { msgId, realSize, dcId } = extractMsgInfo(sent, committedBytes);
+      if (!msgId) throw new Error(`SendMedia returned no messageId for part ${docIdx + 1}`);
+
+      finalDocs.push({
+        index:     docIdx,
+        messageId: msgId,
+        size:      realSize || committedBytes,
+        dcId,
+        partLabel: `.part${docIdx + 1}`,
+      });
+
+      console.log(`[Upload] small-file part ${docIdx + 1} done -> msgId=${msgId} ${formatBytes(realSize || committedBytes)}`);
+      docIdx++;
+      tgPartIdx = 0;
+      tgFileId  = makeTgFileId(docIdx);
+    }
+
+    // ── Big-file path: send one part (exactly PART_SIZE, or true final part) ─
+    // fileTotalParts is a running upper bound. Telegram requires:
+    //   (a) filePart < fileTotalParts on every SaveBigFilePart call
+    //   (b) InputFileBig.parts == exact count at SendMedia
+    async function sendBigPart(buf, fileStream) {
+      const partNo     = tgPartIdx++;
       const docCeiling = (declaredSize > 0 && declaredSize <= PIECE_BYTES)
-        ? declaredSize
-        : PIECE_BYTES;
-      // +1 because partNo is 0-indexed and we just incremented tgPartIdx.
-      // Add a small headroom (+4) for any rounding edge cases.
-      const estTotal = Math.max(
-        tgPartIdx + 4,                         // always > current partNo
-        Math.ceil(docCeiling / PART_SIZE) + 4  // ceiling for remaining parts
+        ? declaredSize : PIECE_BYTES;
+      const estTotal   = Math.max(
+        tgPartIdx + 4,
+        Math.ceil(docCeiling / PART_SIZE) + 4
       );
 
       const p = client.invoke(new Api.upload.SaveBigFilePart({
@@ -305,16 +367,15 @@ app.post('/upload', checkRAM, (req, res) => {
       }
     }
 
-    // Drain partChunks into exactly PART_SIZE sends.
-    // If `final` is true, also flush whatever remains (< PART_SIZE).
+    // Drain accumulation ring into exactly PART_SIZE big-file sends.
+    // If `final` is true, also flush the sub-512KB remainder (true last part only).
     async function drainPartBuf(fileStream, final) {
       while (partLen >= PART_SIZE) {
-        // Collect exactly PART_SIZE bytes
         const slices = [];
         let   need   = PART_SIZE;
         while (need > 0) {
           const top = partChunks[0];
-          if (!top) break; // safety guard
+          if (!top) break;
           if (top.length <= need) {
             slices.push(top);
             need -= top.length;
@@ -327,22 +388,17 @@ app.post('/upload', checkRAM, (req, res) => {
         }
         partLen -= PART_SIZE;
         if (partLen < 0) { console.warn('[BUG] partLen underflow, clamping'); partLen = 0; }
-        await sendPart(Buffer.concat(slices), fileStream);
+        await sendBigPart(Buffer.concat(slices), fileStream);
       }
 
-      // Final call: flush remaining bytes (last part of the ENTIRE file — the
-      // only place a sub-512KB part is legal).
       if (final && partLen > 0) {
         const buf = Buffer.concat(partChunks.splice(0));
         partLen = 0;
-        await sendPart(buf, null);
+        await sendBigPart(buf, null);
       }
     }
 
-    // Finalize current TG document -> SendMedia.
-    // `committedBytes` = exact bytes uploaded into THIS TG doc (supplied by
-    // caller so we never depend on the mutable docBytes variable during
-    // boundary splits where docBytes has already been updated).
+    // Finalize a big-file TG document -> SendMedia with InputFileBig
     async function finalizeDoc(committedBytes) {
       await flushInFlight();
       if (tgPartIdx === 0) return;
@@ -351,12 +407,12 @@ app.post('/upload', checkRAM, (req, res) => {
       const sent   = await client.invoke(new Api.messages.SendMedia({
         peer,
         media: new Api.InputMediaUploadedDocument({
-          file: new Api.InputFileBig({
+          file: new Api.InputFileBig({  // ← InputFileBig for >10 MB files
             id:    tgFileId,
-            parts: tgPartIdx,   // ACTUAL parts sent — critical
+            parts: tgPartIdx,           // ACTUAL parts sent — critical
             name:  tgName,
           }),
-          mimeType:   'application/octet-stream',
+          mimeType:   mimeType || 'application/octet-stream',
           forceFile:  true,
           attributes: [new Api.DocumentAttributeFilename({ fileName: tgName })],
         }),
@@ -375,18 +431,13 @@ app.post('/upload', checkRAM, (req, res) => {
         partLabel: `.part${docIdx + 1}`,
       });
 
-      console.log(`[Upload] part ${docIdx + 1} done -> msgId=${msgId} ${formatBytes(realSize || committedBytes)}`);
-
-      // Reset only TG-doc level counters.
-      // docBytes is intentionally NOT reset here; the data-handler loop
-      // manages it correctly (sets docBytes = partLen after a split, so the
-      // next document's byte accounting starts from the carry-over size).
+      console.log(`[Upload] big-file part ${docIdx + 1} done -> msgId=${msgId} ${formatBytes(realSize || committedBytes)}`);
       docIdx++;
       tgPartIdx = 0;
       tgFileId  = makeTgFileId(docIdx);
     }
 
-    // ── Stream: busboy -> exact 512KB parts -> Telegram ───────────────────
+    // ── Stream: busboy -> dual-path Telegram upload ───────────────────────
     await new Promise((resolve, reject) => {
       const bb = busboy({ headers: req.headers });
 
@@ -398,47 +449,30 @@ app.post('/upload', checkRAM, (req, res) => {
         fileStream.on('data', async (chunk) => {
           fileStream.pause();
           try {
-            let offset = 0;
-
-            while (offset < chunk.length) {
-              // How many bytes can this doc still accept before hitting PIECE_BYTES?
-              const docRemaining = PIECE_BYTES - docBytes;
-              const take         = Math.min(chunk.length - offset, docRemaining);
-
-              // Accumulate exactly `take` bytes into the part buffer
-              const slice = (offset === 0 && take === chunk.length)
-                ? chunk                                   // no-copy fast path
-                : chunk.slice(offset, offset + take);
-
-              partChunks.push(slice);
-              partLen    += take;
-              totalBytes += take;
-              docBytes   += take;
-              offset     += take;
-
-              // Drain complete 512 KB parts (never flushes sub-512KB here)
+            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            partChunks.push(buf);
+            partLen    += buf.length;
+            totalBytes += buf.length;
+            docBytes   += buf.length;
+
+            if (isBigFile) {
+              // ── Big-file path: drain complete 512 KB parts, enforce doc boundary ─
               await drainPartBuf(fileStream, false);
 
-              // If we have hit the 1.9 GB boundary, finalize this TG document.
-              // CRITICAL: do NOT call drainPartBuf(final=true) here.
-              // Any bytes still in partChunks (< 512 KB leftover) stay in the
-              // buffer and will be prepended to the NEXT document's stream,
-              // satisfying Telegram's rule that only the very last part of
-              // the ENTIRE file may be < 512 KB.
               if (docBytes >= PIECE_BYTES) {
-                // Drain any whole 512KB parts that exactly fill up right here
-                // (handles the edge case where docBytes lands on a part boundary)
-                await drainPartBuf(fileStream, false);
-                // committedBytes = bytes that actually went into this TG doc.
-                // partLen is the carry-over that will belong to the NEXT doc.
+                await drainPartBuf(fileStream, false); // drain any newly-aligned parts
                 const committedToThisDoc = PIECE_BYTES - partLen;
                 await finalizeDoc(committedToThisDoc);
-                // partChunks / partLen carry over — intentional
-                // Reset docBytes to the carry-over size so the next doc's
-                // byte accounting is correct from the start.
-                docBytes = partLen;
+                docBytes = partLen; // carry-over belongs to next doc
               }
+
+            } else if (declaredSize <= 0 && partLen > SMALL_FILE_THRESHOLD) {
+              // ── Unknown size crossed threshold mid-stream: switch to big-file ──
+              isBigFile = true;
+              console.log(`[Upload] "${fileName}" exceeds ${formatBytes(SMALL_FILE_THRESHOLD)}, switching to big-file path`);
+              await drainPartBuf(fileStream, false);
             }
+            // else: small-file path — just keep buffering until stream end
 
             fileStream.resume();
           } catch (e) { reject(e); }
@@ -446,8 +480,21 @@ app.post('/upload', checkRAM, (req, res) => {
 
         fileStream.on('end', async () => {
           try {
-            await drainPartBuf(null, true);  // flush last partial part (true final)
-            await finalizeDoc(docBytes);     // finalize last TG doc
+            // Resolve path for files with unknown declared size
+            if (!isBigFile && declaredSize <= 0) {
+              isBigFile = (totalBytes > SMALL_FILE_THRESHOLD);
+            }
+
+            if (isBigFile) {
+              // ── Big-file path: flush remainder and finalize ──────────────
+              await drainPartBuf(null, true);
+              await finalizeDoc(docBytes);
+            } else {
+              // ── Small-file path: entire file is in partChunks (≤ 10 MB) ─
+              const fullBuf = Buffer.concat(partChunks.splice(0));
+              partLen = 0;
+              await uploadSmallFile(fullBuf, totalBytes);
+            }
             resolve();
           } catch (e) { reject(e); }
         });