Update server.js

server.js

@@ -56,8 +56,8 @@ const CONFIG = {
   TIKTOK_CLIENT_SECRET: process.env.TIKTOK_CLIENT_SECRET || "hh",
   TIKTOK_REDIRECT_URI: process.env.TIKTOK_REDIRECT_URI || "https://content.nett.to/auth/tiktok/callback",
 
-  JWT_SECRET: process.env.JWT_SECRET || "hh",
-  LONGCAT_API_KEY: process.env.LONGCAT_API_KEY || "hh",
+  JWT_SECRET: process.env.JWT_SECRET || "key",
+  LONGCAT_API_KEY: process.env.LONGCAT_API_KEY || "akkey",
 
   PORT: process.env.PORT || 3000,
   CHUNK_SIZE: 10 * 1024 * 1024, // 10MB
@@ -107,7 +107,7 @@ app.get("/auth/tiktok", (req, res) => {
   const url =
     "https://www.tiktok.com/v2/auth/authorize/" +
     "?client_key=" + CONFIG.TIKTOK_CLIENT_KEY +
-    "&scope=video.publish,video.upload,user.info.basic,user.info.profile,user.info.stats" +
+    "&scope=video.publish,user.info.basic,user.info.profile" +
     "&response_type=code" +
     "&redirect_uri=" + encodeURIComponent(CONFIG.TIKTOK_REDIRECT_URI) +
     "&state=" + state;
@@ -212,7 +212,7 @@ app.get("/auth/tiktok/callback", async (req, res) => {
 app.get("/me", requireAuth, async (req, res) => {
   try {
     const userRes = await axios.get(
-      "https://open.tiktokapis.com/v2/user/info/?fields=display_name,avatar_url,username,follower_count,following_count,likes_count,video_count",
+      "https://open.tiktokapis.com/v2/user/info/?fields=display_name,avatar_url,follower_count,following_count,likes_count,video_count,username",
       { headers: { Authorization: `Bearer ${req.user.tiktok_access_token}` } }
     );
     const data = userRes.data;
@@ -397,16 +397,7 @@ async function runPipeline(jobId, theme, user, jobDirs) {
       }
     );
     updateJob(jobId, { stepDetail: `Encoding video (${questionsUsed} questions, ${totalDuration.toFixed(1)}s)`, progress: 100 });
-
-    // Sanity check — a valid 60s 1080x1920 H.264 video should be at least 3 MB
-    const videoBytes = fs.statSync(videoPath).size;
-    console.log(`✅ [${jobId}] Video ready: ${videoPath} (${(videoBytes / 1024 / 1024).toFixed(2)} MB)`);
-    if (videoBytes < 3 * 1024 * 1024) {
-      throw new Error(
-        `Video file is suspiciously small (${(videoBytes / 1024 / 1024).toFixed(2)} MB) — ` +
-        `ffmpeg likely failed silently. Check that libx264 is installed: run 'ffmpeg -codecs | grep h264'`
-      );
-    }
+    console.log(`✅ [${jobId}] Video ready: ${videoPath}`);
 
     // --- Step 5: Upload to TikTok ---
     const caption = `Would You Rather: ${theme.charAt(0).toUpperCase() + theme.slice(1)} Edition 🤔 #wouldyourather #${theme.replace(/\s+/g, "")} #fyp`;
@@ -650,41 +641,40 @@ async function renderFrame(question, phase, outputPath) {
 
   if (phase === "question") {
     // ---- QUESTION PHASE ----
-
-    // "Would You Rather..." header
+    // Question text at top
     ctx.fillStyle = "#FFFFFF";
     ctx.font = "bold 58px sans-serif";
     ctx.textAlign = "center";
-    wrapText(ctx, "Would You Rather...", W / 2, 160, W - 80, 70);
+    wrapText(ctx, "Would You Rather...", W / 2, 200, W - 80, 70);
 
-    // Option 1 — RED (top half, from y=260 to H/2-10)
-    ctx.fillStyle = "#CC0000";
-    ctx.fillRect(0, 260, W, H / 2 - 270);
-    ctx.fillStyle = "#FFFFFF";
-    ctx.font = "bold 68px sans-serif";
-    ctx.textAlign = "center";
-    wrapText(ctx, question.option1, W / 2, 400, W - 120, 82);
-
-    // Divider line at center
-    ctx.strokeStyle = "#222222";
-    ctx.lineWidth = 6;
+    // Divider line
+    ctx.strokeStyle = "#444444";
+    ctx.lineWidth = 4;
     ctx.beginPath();
     ctx.moveTo(0, H / 2);
     ctx.lineTo(W, H / 2);
     ctx.stroke();
 
-    // Option 2 — BLUE (bottom half, from H/2+10 to H-100)
+    // Option 1 — RED (top half)
+    ctx.fillStyle = "#CC0000";
+    ctx.fillRect(0, 320, W, H / 2 - 320);
+    ctx.fillStyle = "#FFFFFF";
+    ctx.font = "bold 72px sans-serif";
+    ctx.textAlign = "center";
+    wrapText(ctx, question.option1, W / 2, 520, W - 100, 85);
+
+    // Option 2 — BLUE (bottom half)
     ctx.fillStyle = "#0055CC";
-    ctx.fillRect(0, H / 2 + 10, W, H / 2 - 110);
+    ctx.fillRect(0, H / 2, W, H / 2 - 100);
     ctx.fillStyle = "#FFFFFF";
-    ctx.font = "bold 68px sans-serif";
+    ctx.font = "bold 72px sans-serif";
     ctx.textAlign = "center";
-    wrapText(ctx, question.option2, W / 2, H / 2 + 160, W - 120, 82);
+    wrapText(ctx, question.option2, W / 2, H / 2 + 200, W - 100, 85);
 
-    // OR badge over the divider
+    // OR badge in center
     ctx.fillStyle = "#FFFFFF";
     ctx.beginPath();
-    ctx.arc(W / 2, H / 2, 72, 0, Math.PI * 2);
+    ctx.arc(W / 2, H / 2, 70, 0, Math.PI * 2);
     ctx.fill();
     ctx.fillStyle = "#111111";
     ctx.font = "bold 52px sans-serif";
@@ -695,42 +685,35 @@ async function renderFrame(question, phase, outputPath) {
     // ---- RESULT PHASE ----
     const winner1 = question.pct1 >= question.pct2;
 
-    // --- Top half: Option 1 ---
+    // Option 1 block
     ctx.fillStyle = "#CC0000";
     ctx.fillRect(0, 0, W, H / 2 - 10);
-
-    // Option 1 label text — start at y=200, track where it ends
     ctx.fillStyle = "#FFFFFF";
-    ctx.font = "bold 60px sans-serif";
+    ctx.font = "bold 64px sans-serif";
     ctx.textAlign = "center";
-    const opt1EndY = wrapText(ctx, question.option1, W / 2, 200, W - 100, 72);
+    wrapText(ctx, question.option1, W / 2, 280, W - 80, 76);
 
-    // Percentage below the text with a safe gap
-    const pct1Y = Math.min(opt1EndY + 130, H / 2 - 80);
-    ctx.font = "bold 160px sans-serif";
-    ctx.fillStyle = winner1 ? "#00FF88" : "#FF6666";
-    ctx.fillText(`${question.pct1}%`, W / 2, pct1Y);
+    // Option 1 percentage
+    ctx.font = `bold 150px sans-serif`;
+    ctx.fillStyle = winner1 ? "#00FF88" : "#FF4444";
+    ctx.fillText(`${question.pct1}%`, W / 2, 680);
 
-    // --- Divider ---
+    // Divider
     ctx.fillStyle = "#111111";
     ctx.fillRect(0, H / 2 - 10, W, 20);
 
-    // --- Bottom half: Option 2 ---
+    // Option 2 block
     ctx.fillStyle = "#0055CC";
     ctx.fillRect(0, H / 2 + 10, W, H / 2 - 10);
-
-    // Option 2 label text — start below the divider
     ctx.fillStyle = "#FFFFFF";
-    ctx.font = "bold 60px sans-serif";
+    ctx.font = "bold 64px sans-serif";
     ctx.textAlign = "center";
-    const opt2StartY = H / 2 + 160;
-    const opt2EndY = wrapText(ctx, question.option2, W / 2, opt2StartY, W - 100, 72);
-
-    // Percentage below the text with a safe gap
-    const pct2Y = Math.min(opt2EndY + 130, H - 80);
-    ctx.font = "bold 160px sans-serif";
-    ctx.fillStyle = !winner1 ? "#00FF88" : "#FF6666";
-    ctx.fillText(`${question.pct2}%`, W / 2, pct2Y);
+    wrapText(ctx, question.option2, W / 2, H / 2 + 230, W - 80, 76);
+
+    // Option 2 percentage
+    ctx.font = `bold 150px sans-serif`;
+    ctx.fillStyle = !winner1 ? "#00FF88" : "#FF4444";
+    ctx.fillText(`${question.pct2}%`, W / 2, H / 2 + 600);
   }
 
   const buffer = canvas.toBuffer("image/png");
@@ -815,19 +798,15 @@ async function buildVideo(questions, audioFiles, framesDir, videosDir, onProgres
     const rFrame = path.join(framesDir, `q${i + 1}_result.png`);
     await renderFrame(q, "result", rFrame);
 
-    // ffmpeg concat format: escape single quotes in paths
-    const safeQ = qFrame.replace(/'/g, "'\\''");
-    const safeR = rFrame.replace(/'/g, "'\\''");
-    concatList.push(`file '${safeQ}'\nduration ${questionDuration}`);
-    concatList.push(`file '${safeR}'\nduration ${resultDuration}`);
+    concatList.push(`file '${qFrame}'\nduration ${questionDuration}`);
+    concatList.push(`file '${rFrame}'\nduration ${resultDuration}`);
 
     if (onProgress) onProgress(i + 1, usedQuestions.length);
   }
 
   // ffmpeg concat requires the last entry repeated without a duration
   const lastResult = path.join(framesDir, `q${usedQuestions.length}_result.png`);
-  const safeLastResult = lastResult.replace(/'/g, "'\\''");
-  concatList.push(`file '${safeLastResult}'`);
+  concatList.push(`file '${lastResult}'`);
   fs.writeFileSync(framesList, concatList.join("\n"));
 
   // ------------------------------------------------------------------
@@ -843,29 +822,37 @@ async function buildVideo(questions, audioFiles, framesDir, videosDir, onProgres
   await new Promise((resolve, reject) => {
     ffmpeg()
       .input(framesList)
-      .inputOptions([
-        "-f concat",
-        "-safe 0",
-        "-r 30",        // ← REQUIRED: set input framerate for image concat demuxer
-                        //   without this, ffmpeg ignores `duration` directives
-      ])
+      // -framerate is REQUIRED when concatenating still images with duration directives.
+      // Without it ffmpeg ignores the duration lines and produces a near-zero-length video.
+      .inputOptions(["-f concat", "-safe 0", "-framerate 30"])
       .input(combinedAudio)
       .outputOptions([
         "-c:v libx264",
-        "-preset fast",
-        "-crf 23",      // quality — lower = better, 23 is a good default
+        "-r 30",           // output framerate must match input
         "-pix_fmt yuv420p",
-        "-r 30",        // output framerate
+        "-preset fast",
+        "-crf 23",
         "-c:a aac",
-        "-b:a 192k",
-        // NOTE: no -shortest — it can cut the video early if frame/audio timing
-        // has any floating-point mismatch. We control duration via the concat list.
+        "-shortest",
         "-movflags +faststart",
       ])
       .output(videoPath)
-      .on("end", resolve)
-      .on("error", (err, stdout, stderr) => {
-        reject(new Error(`Video encode ffmpeg error: ${err.message}\nstderr: ${stderr}`));
+      .on("start", (cmdLine) => console.log("ffmpeg cmd:", cmdLine))
+      .on("stderr", (line) => console.log("ffmpeg:", line))
+      .on("end", () => {
+        let fileSize = 0;
+        try { fileSize = fs.statSync(videoPath).size; } catch (_) {}
+        if (fileSize < 50 * 1024) {
+          return reject(new Error(
+            `ffmpeg finished but output is only ${(fileSize / 1024).toFixed(1)} KB — ` +
+            `check server logs above for ffmpeg stderr output.`
+          ));
+        }
+        console.log(`✅ Video encoded: ${(fileSize / 1024 / 1024).toFixed(2)} MB`);
+        resolve();
+      })
+      .on("error", (err, _stdout, stderr) => {
+        reject(new Error(`ffmpeg error: ${err.message}\nstderr: ${stderr}`));
       })
       .run();
   });
@@ -878,7 +865,7 @@ async function buildVideo(questions, audioFiles, framesDir, videosDir, onProgres
 // ============================================================
 function concatAudio(files, output, audioDir) {
   const listPath = path.join(audioDir, "audio_list.txt");
-  const content = files.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n");
+  const content = files.map((f) => `file '${f}'`).join("\n");
   fs.writeFileSync(listPath, content);
 
   return new Promise((resolve, reject) => {
@@ -886,16 +873,14 @@ function concatAudio(files, output, audioDir) {
       .input(listPath)
       .inputOptions(["-f concat", "-safe 0"])
       .outputOptions([
-        "-acodec libmp3lame",
+        "-acodec libmp3lame", // re-encode so mismatched bitrates/sample-rates never cause failures
         "-ar 44100",
         "-ac 2",
-        "-q:a 2",
+        "-q:a 2",           // VBR ~190kbps — good quality, small file
       ])
       .output(output)
       .on("end", resolve)
-      .on("error", (err, stdout, stderr) => {
-        reject(new Error(`concatAudio ffmpeg error: ${err.message}\nstderr: ${stderr}`));
-      })
+      .on("error", reject)
       .run();
   });
 }
@@ -905,170 +890,89 @@ function concatAudio(files, output, audioDir) {
 // ============================================================
 async function postToTikTok(accessToken, videoPath, caption, onChunkProgress, onPollProgress) {
   const videoSizeBytes = fs.statSync(videoPath).size;
+  const totalChunks = Math.ceil(videoSizeBytes / CONFIG.CHUNK_SIZE);
 
-  // TikTok chunk rules (from docs):
-  //   - Each chunk must be >= 5 MB, except the last chunk
-  //   - Each chunk must be <= 64 MB
-  //   - Files < 5 MB must be uploaded whole (chunk_size = video_size, total_chunk_count = 1)
-  //   - Files > 64 MB must be split into multiple chunks
-  const MIN_CHUNK = 5 * 1024 * 1024;   //  5 MB
-  const MAX_CHUNK = 64 * 1024 * 1024;  // 64 MB
-
-  let chunkSize;
-  if (videoSizeBytes <= MAX_CHUNK) {
-    // Upload the whole file in one chunk — satisfies both the < 5 MB and the 5–64 MB cases
-    chunkSize = videoSizeBytes;
-  } else {
-    // Use 10 MB chunks for large files; stays safely within 5–64 MB bounds
-    chunkSize = CONFIG.CHUNK_SIZE; // 10 MB
-  }
-
-  const totalChunks = Math.ceil(videoSizeBytes / chunkSize);
-  console.log(`Video size: ${(videoSizeBytes / 1024 / 1024).toFixed(2)} MB | chunk size: ${(chunkSize / 1024 / 1024).toFixed(2)} MB | chunks: ${totalChunks}`);
-
-  // ── Step 0: Query creator info (REQUIRED before init per TikTok docs) ──────
-  // This also tells us which privacy_level values are valid for this account.
-  let privacyLevel = "SELF_ONLY"; // safe fallback
-  try {
-    const creatorRes = await axios.post(
-      "https://open.tiktokapis.com/v2/post/publish/creator_info/query/",
-      {},
-      {
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json; charset=UTF-8",
-        },
-      }
-    );
-    const creatorData = creatorRes.data;
-    console.log("Creator info:", JSON.stringify(creatorData));
-
-    if (creatorData.error?.code !== "ok") {
-      throw new Error(`Creator info query failed: ${creatorData.error?.message}`);
-    }
-
-    // Use the first available privacy option — SELF_ONLY is always safe for unaudited apps
-    const options = creatorData.data?.privacy_level_options || [];
-    privacyLevel = options.includes("SELF_ONLY") ? "SELF_ONLY"
-                 : options[0] || "SELF_ONLY";
-
-    console.log(`Privacy options: ${options.join(", ")} → using ${privacyLevel}`);
-  } catch (err) {
-    // Non-fatal for creator_info — proceed with SELF_ONLY, init may still work
-    console.warn("creator_info/query failed (non-fatal):", err.message);
-  }
-
-  // ── Step 1: Init upload ───────────────────────────────────────────────────
-  let initData;
-  try {
-    const initRes = await axios.post(
-      "https://open.tiktokapis.com/v2/post/publish/video/init/",
-      {
-        post_info: {
-          title: caption,
-          privacy_level: privacyLevel,
-          disable_duet: false,
-          disable_comment: false,
-          disable_stitch: false,
-          video_cover_timestamp_ms: 1000,
-        },
-        source_info: {
-          source: "FILE_UPLOAD",
-          video_size: videoSizeBytes,
-          chunk_size: chunkSize,
-          total_chunk_count: totalChunks,
-        },
+  // Init upload
+  const initRes = await axios.post(
+    "https://open.tiktokapis.com/v2/post/publish/video/init/",
+    {
+      post_info: {
+        title: caption,
+        privacy_level: "SELF_ONLY", // Change to PUBLIC_TO_EVERYONE after app audit
+        disable_duet: false,
+        disable_comment: false,
+        disable_stitch: false,
+        video_cover_timestamp_ms: 1000,
+      },
+      source_info: {
+        source: "FILE_UPLOAD",
+        video_size: videoSizeBytes,
+        chunk_size: CONFIG.CHUNK_SIZE,
+        total_chunk_count: totalChunks,
+      },
+    },
+    {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json; charset=UTF-8",
       },
-      {
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json; charset=UTF-8",
-        },
-      }
-    );
-    initData = initRes.data;
-  } catch (err) {
-    // Axios throws on 4xx/5xx — log the full TikTok error body
-    const body = err.response?.data;
-    const code = body?.error?.code;
-
-    if (code === "unaudited_client_can_only_post_to_private_accounts") {
-      throw new Error(
-        "Your TikTok account must be set to PRIVATE before posting. " +
-        "Go to TikTok → Settings → Privacy → set account to Private. " +
-        "Once the app passes TikTok's audit you can switch back to Public."
-      );
     }
+  );
 
-    throw new Error(`Init upload HTTP ${err.response?.status}: ${JSON.stringify(body)}`);
-  }
-
+  const initData = initRes.data;
   if (initData.error?.code !== "ok") {
-    throw new Error(`Init upload failed: ${initData.error?.message} (code: ${initData.error?.code})`);
+    throw new Error(`Init upload failed: ${initData.error?.message}`);
   }
 
   const { publish_id, upload_url } = initData.data;
-  console.log(`Init OK — publish_id: ${publish_id}`);
 
-  // ── Step 2: Upload chunks ─────────────────────────────────────────────────
+  // Upload chunks — stream each chunk directly from disk, no full-file buffer
   const fd = fs.openSync(videoPath, "r");
   try {
     for (let i = 0; i < totalChunks; i++) {
-      const start = i * chunkSize;
-      const end = Math.min(start + chunkSize, videoSizeBytes) - 1;
+      const start = i * CONFIG.CHUNK_SIZE;
+      const end = Math.min(start + CONFIG.CHUNK_SIZE, videoSizeBytes) - 1;
       const chunkLen = end - start + 1;
       const chunk = Buffer.allocUnsafe(chunkLen);
       fs.readSync(fd, chunk, 0, chunkLen, start);
 
-      try {
-        await axios.put(upload_url, chunk, {
-          headers: {
-            "Content-Range": `bytes ${start}-${end}/${videoSizeBytes}`,
-            "Content-Type": "video/mp4",
-            "Content-Length": chunkLen,
-          },
-          maxBodyLength: Infinity,
-          maxContentLength: Infinity,
-        });
-      } catch (err) {
-        throw new Error(`Chunk ${i + 1} upload HTTP ${err.response?.status}: ${JSON.stringify(err.response?.data)}`);
-      }
+      await axios.put(upload_url, chunk, {
+        headers: {
+          "Content-Range": `bytes ${start}-${end}/${videoSizeBytes}`,
+          "Content-Type": "video/mp4",
+          "Content-Length": chunkLen,
+        },
+        maxBodyLength: Infinity,
+        maxContentLength: Infinity,
+      });
 
       if (onChunkProgress) onChunkProgress(i + 1, totalChunks);
     }
   } finally {
-    fs.closeSync(fd);
+    fs.closeSync(fd); // always release the file descriptor
   }
 
-  // ── Step 3: Poll publish status ───────────────────────────────────────────
-  for (let attempt = 1; attempt <= 20; attempt++) {
+  // Poll status
+  for (let attempt = 1; attempt <= 15; attempt++) {
     await new Promise((r) => setTimeout(r, 5000));
-
-    let statusData;
-    try {
-      const statusRes = await axios.post(
-        "https://open.tiktokapis.com/v2/post/publish/status/fetch/",
-        { publish_id },
-        {
-          headers: {
-            Authorization: `Bearer ${accessToken}`,
-            "Content-Type": "application/json; charset=UTF-8",
-          },
-        }
-      );
-      statusData = statusRes.data;
-    } catch (err) {
-      console.warn(`Poll ${attempt} failed:`, err.message);
-      continue;
-    }
-
+    const statusRes = await axios.post(
+      "https://open.tiktokapis.com/v2/post/publish/status/fetch/",
+      { publish_id },
+      {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json; charset=UTF-8",
+        },
+      }
+    );
+    const statusData = statusRes.data;
     const status = statusData.data?.status;
     console.log(`   Poll ${attempt}: ${status}`);
     if (onPollProgress) onPollProgress(status, statusData.data?.uploaded_bytes);
     if (status === "PUBLISH_COMPLETE") return statusData.data;
     if (status === "FAILED") throw new Error(`Post failed: ${JSON.stringify(statusData.data)}`);
   }
-  throw new Error("Timed out waiting for TikTok to process the video");
+  throw new Error("Timed out waiting for post");
 }
 
 // ============================================================
@@ -1128,7 +1032,6 @@ function wrapText(ctx, text, x, y, maxWidth, lineHeight) {
     }
   }
   ctx.fillText(line.trim(), x, currentY);
-  return currentY; // return final Y so callers can place elements below the text
 }
 
 // ============================================================