fluncle 0.68.0 → 0.69.0

package/bin/fluncle.mjs

@@ -423,7 +423,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.68.0".trim() ? "0.68.0".trim() : "0.1.0";
+  currentVersion = "0.69.0".trim() ? "0.69.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -1212,6 +1212,177 @@ var init_mixtape_mixcloud = __esm(() => {
   PICTURE_MAX_BYTES = 10 * 1024 * 1024;
 });
 
+// src/commands/mixtape-set-video.ts
+var exports_mixtape_set_video = {};
+__export(exports_mixtape_set_video, {
+  stageSetVideo: () => stageSetVideo,
+  renditionFfmpegArgs: () => renditionFfmpegArgs,
+  planMultipart: () => planMultipart,
+  buildCompleteXml: () => buildCompleteXml,
+  SET_VIDEO_RENDITION: () => SET_VIDEO_RENDITION,
+  MIN_PART_SIZE: () => MIN_PART_SIZE,
+  MAX_PARTS: () => MAX_PARTS,
+  DEFAULT_PART_SIZE: () => DEFAULT_PART_SIZE
+});
+import { randomUUID } from "node:crypto";
+import { existsSync, rmSync as rmSync2, statSync as statSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join4 } from "node:path";
+function planMultipart(contentLength, partSize = DEFAULT_PART_SIZE) {
+  if (!Number.isInteger(contentLength) || contentLength <= 0) {
+    throw new CliError2("invalid_size", `The rendition size must be a positive integer (got ${contentLength})`);
+  }
+  let effective = Math.max(partSize, MIN_PART_SIZE);
+  if (Math.ceil(contentLength / effective) > MAX_PARTS) {
+    effective = Math.ceil(contentLength / MAX_PARTS);
+  }
+  const parts = [];
+  let start = 0;
+  let partNumber = 1;
+  while (start < contentLength) {
+    const end = Math.min(start + effective, contentLength);
+    parts.push({ end, partNumber, size: end - start, start });
+    start = end;
+    partNumber += 1;
+  }
+  return { partCount: parts.length, partSize: effective, parts };
+}
+function escapeXml(value) {
+  return value.replace(/[<>&'"]/g, (char) => ({ '"': "&quot;", "&": "&amp;", "'": "&apos;", "<": "&lt;", ">": "&gt;" })[char] ?? char);
+}
+function buildCompleteXml(parts) {
+  const ordered = [...parts].sort((a, b) => a.partNumber - b.partNumber);
+  const body = ordered.map((part) => `<Part><PartNumber>${part.partNumber}</PartNumber><ETag>${escapeXml(part.etag)}</ETag></Part>`).join("");
+  return `<CompleteMultipartUpload>${body}</CompleteMultipartUpload>`;
+}
+function renditionFfmpegArgs(inputPath, outputPath) {
+  return [
+    "-y",
+    "-i",
+    inputPath,
+    "-vf",
+    `scale=-2:${SET_VIDEO_RENDITION.height}`,
+    "-c:v",
+    "libx264",
+    "-preset",
+    "medium",
+    "-crf",
+    String(SET_VIDEO_RENDITION.crf),
+    "-force_key_frames",
+    `expr:gte(t,n_forced*${SET_VIDEO_RENDITION.gopSeconds})`,
+    "-pix_fmt",
+    "yuv420p",
+    "-c:a",
+    "aac",
+    "-b:a",
+    SET_VIDEO_RENDITION.audioBitrate,
+    "-movflags",
+    "+faststart",
+    outputPath
+  ];
+}
+async function stageSetVideo(mixtapeId, masterPath, onProgress = () => {}) {
+  if (!existsSync(masterPath)) {
+    throw new CliError2("file_not_found", `Set-video master not found: ${masterPath}`);
+  }
+  await assertFfmpeg();
+  const renditionPath = join4(tmpdir(), `fluncle-set-${randomUUID()}.mp4`);
+  onProgress("Set video: deriving the 1080p faststart rendition (ffmpeg)…");
+  await deriveRendition(masterPath, renditionPath);
+  try {
+    const size = statSync2(renditionPath).size;
+    const plan = planMultipart(size);
+    onProgress(`Set video: uploading ${(size / 1e9).toFixed(2)} GB in ${plan.partCount} part(s)…`);
+    const presign = await adminApiPost(`/api/admin/mixtapes/${encodeURIComponent(mixtapeId)}/set-video/presign`, { partCount: plan.partCount });
+    const urlByPart = new Map(presign.parts.map((part) => [part.partNumber, part.url]));
+    const completed = [];
+    try {
+      for (const part of plan.parts) {
+        const url = urlByPart.get(part.partNumber);
+        if (!url) {
+          throw new CliError2("presign_missing", `Worker did not sign part ${part.partNumber} of ${plan.partCount}`);
+        }
+        onProgress(`Set video: part ${part.partNumber}/${plan.partCount}`);
+        const etag = await putPart(url, renditionPath, part);
+        completed.push({ etag, partNumber: part.partNumber });
+      }
+      await completeUpload(presign.completeUrl, completed);
+    } catch (error) {
+      await abortUpload(presign.abortUrl).catch(() => {});
+      throw error;
+    }
+    await adminApiPatch(`/api/admin/mixtapes/${encodeURIComponent(mixtapeId)}`, { setVideoAt: new Date().toISOString() });
+    onProgress("Set video: flipped setVideoAt — the /log player + video SEO are live.");
+    return { key: presign.key, url: `${FOUND_BASE}/${presign.key}` };
+  } finally {
+    rmSync2(renditionPath, { force: true });
+  }
+}
+async function putPart(url, path2, part) {
+  const response = await fetch(url, {
+    body: Bun.file(path2).slice(part.start, part.end),
+    method: "PUT"
+  });
+  if (!response.ok) {
+    const detail = (await response.text().catch(() => "")).slice(0, 300);
+    throw new CliError2("r2_part_failed", `R2 rejected part ${part.partNumber} (${response.status} ${response.statusText})${detail ? `: ${detail}` : ""}`);
+  }
+  const etag = response.headers.get("etag");
+  if (!etag) {
+    throw new CliError2("r2_no_etag", `R2 returned no ETag for part ${part.partNumber}`);
+  }
+  return etag;
+}
+async function completeUpload(url, parts) {
+  const response = await fetch(url, {
+    body: buildCompleteXml(parts),
+    headers: { "content-type": "application/xml" },
+    method: "POST"
+  });
+  const text = await response.text().catch(() => "");
+  if (!response.ok || text.includes("<Error>")) {
+    throw new CliError2("r2_complete_failed", `R2 CompleteMultipartUpload failed (${response.status} ${response.statusText})${text ? `: ${text.slice(0, 300)}` : ""}`);
+  }
+}
+async function abortUpload(url) {
+  await fetch(url, { method: "DELETE" });
+}
+async function assertFfmpeg() {
+  try {
+    const proc = Bun.spawn(["ffmpeg", "-version"], { stderr: "ignore", stdout: "ignore" });
+    await proc.exited;
+    if (proc.exitCode !== 0) {
+      throw new Error("ffmpeg -version exited non-zero");
+    }
+  } catch {
+    throw new CliError2("ffmpeg_missing", "--set-video needs ffmpeg to derive the 1080p rendition. Install it (brew install ffmpeg).");
+  }
+}
+async function deriveRendition(inputPath, outputPath) {
+  const proc = Bun.spawn(["ffmpeg", ...renditionFfmpegArgs(inputPath, outputPath)], {
+    stderr: "pipe",
+    stdout: "ignore"
+  });
+  await proc.exited;
+  if (proc.exitCode !== 0) {
+    const detail = (await new Response(proc.stderr).text().catch(() => "")).slice(-400);
+    throw new CliError2("ffmpeg_failed", `ffmpeg failed to derive the set-video rendition${detail ? `: ${detail}` : ""}`);
+  }
+}
+var FOUND_BASE = "https://found.fluncle.com", SET_VIDEO_RENDITION, DEFAULT_PART_SIZE, MIN_PART_SIZE, MAX_PARTS = 1e4;
+var init_mixtape_set_video = __esm(() => {
+  init_api();
+  init_output();
+  SET_VIDEO_RENDITION = {
+    audioBitrate: "192k",
+    crf: 20,
+    gopSeconds: 2,
+    height: 1080
+  };
+  DEFAULT_PART_SIZE = 100 * 1024 * 1024;
+  MIN_PART_SIZE = 5 * 1024 * 1024;
+});
+
 // src/commands/mixtapes.ts
 var exports_mixtapes = {};
 __export(exports_mixtapes, {
@@ -1225,7 +1396,7 @@ __export(exports_mixtapes, {
   mixtapeDeleteCommand: () => mixtapeDeleteCommand,
   mixtapeCreateCommand: () => mixtapeCreateCommand
 });
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 async function mixtapesCommand() {
   const response = await publicApiGet("/api/mixtapes");
   return response.mixtapes;
@@ -1266,15 +1437,19 @@ async function mixtapeDistributeCommand(idOrLogId, options, onProgress = () => {
   if (!mixtape.id) {
     throw new CliError2("mixtape_not_found", `No mixtape with id or log id ${idOrLogId}`);
   }
-  const both = !options.youtube && !options.mixcloud;
+  const both = !options.youtube && !options.mixcloud && !options.setVideo;
   const doYoutube = both || Boolean(options.youtube);
   const doMixcloud = both || Boolean(options.mixcloud);
+  const doSetVideo = Boolean(options.setVideo);
   if (doYoutube && !options.video) {
     throw new CliError2("missing_video", "YouTube distribution needs --video <mp4>");
   }
   if (doMixcloud && !options.audio) {
     throw new CliError2("missing_audio", "Mixcloud distribution needs --audio <file>");
   }
+  if (doSetVideo && !options.video) {
+    throw new CliError2("missing_video", "--set-video needs --video <master.mp4>");
+  }
   const mixtapeId = mixtape.id;
   let logId = mixtape.logId;
   if (!mixtape.durationMs) {
@@ -1319,6 +1494,16 @@ async function mixtapeDistributeCommand(idOrLogId, options, onProgress = () => {
     results.push({ platform: "mixcloud", url: result.url });
     onProgress(`Mixcloud: ${result.url}`);
   }
+  if (doSetVideo) {
+    if (!options.video) {
+      throw new CliError2("missing_video", "--set-video needs --video <master.mp4>");
+    }
+    onProgress("Set video: staging the 1080p rendition…");
+    const { stageSetVideo: stageSetVideo2 } = await Promise.resolve().then(() => (init_mixtape_set_video(), exports_mixtape_set_video));
+    const result = await stageSetVideo2(mixtapeId, options.video, onProgress);
+    results.push({ platform: "set-video", url: result.url });
+    onProgress(`Set video: ${result.url}`);
+  }
   return { logId, mixtapeId, results };
 }
 async function probeDurationMs(filePath) {
@@ -1353,7 +1538,7 @@ function buildBody(options) {
   return body;
 }
 function parseCueFile(filePath) {
-  if (!existsSync(filePath)) {
+  if (!existsSync2(filePath)) {
     throw new CliError2("file_not_found", `Cue file not found: ${filePath}`);
   }
   const text = readFileSync2(filePath, "utf-8");
@@ -2138,7 +2323,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.68.0".trim() ? "0.68.0".trim() : "0.1.0";
+  currentVersion2 = "0.69.0".trim() ? "0.69.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -2673,10 +2858,8 @@ var init_src = __esm(() => {
       ],
       kind: "extension",
       name: "extension.lens",
-      operatorNotes: "Fluncle Lens (apps/extension), MV3. PENDING Chrome Web Store review — DARK until approval, then flip `pending` + set the assigned listing URL. The placeholder `url` is the store search for the listing; probeConfig is the post-approval /status check.",
-      pending: true,
-      probeConfig: { cadenceMs: PROBE_CADENCE_MS, kind: "http", timeoutMs: PROBE_TIMEOUT_MS },
-      url: "https://chromewebstore.google.com/search/Fluncle%20Lens",
+      operatorNotes: "Fluncle Lens (apps/extension), MV3, LIVE on the Chrome Web Store (published 2026-06-29). Store listing reachability is Google's, not ours, so it is not on the /status board.",
+      url: "https://chromewebstore.google.com/detail/efkkceaofendabikblfjhoepgejfpakk",
       weights: { web: "secondary" }
     },
     {
@@ -2894,7 +3077,7 @@ async function trackVideoCommand(idOrLogId, files, onProgress) {
       const detail = (await response.text().catch(() => "")).slice(0, 300);
       throw new CliError2("r2_put_failed", `R2 rejected ${spec.field} with ${response.status} ${response.statusText}${detail ? `: ${detail}` : ""}`);
     }
-    urls[spec.field] = `${FOUND_BASE}/${upload.key}`;
+    urls[spec.field] = `${FOUND_BASE2}/${upload.key}`;
   }
   const manifest = files.render ? await readManifestFields(files.render) : {};
   const videoModel = files.model?.trim().slice(0, 120) || manifest.model || DEFAULT_VIDEO_MODEL;
@@ -3004,7 +3187,7 @@ async function trackNoteCommand(idOrLogId, options) {
   const body = { note: options.note };
   return adminApiPost(`/api/admin/tracks/${encodeURIComponent(idOrLogId)}/note`, body);
 }
-var DEFAULT_VIDEO_MODEL = "anthropic/claude-opus-4-8", DEFAULT_VIDEO_REASONING = "high", FOUND_BASE = "https://found.fluncle.com", VIDEO_FIELDS;
+var DEFAULT_VIDEO_MODEL = "anthropic/claude-opus-4-8", DEFAULT_VIDEO_REASONING = "high", FOUND_BASE2 = "https://found.fluncle.com", VIDEO_FIELDS;
 var init_track = __esm(() => {
   init_api();
   init_output();
@@ -3437,7 +3620,7 @@ __export(exports_mixtape_youtube2, {
   distributeYoutube: () => distributeYoutube2,
   authYoutubeCommand: () => authYoutubeCommand2
 });
-import { statSync as statSync2 } from "node:fs";
+import { statSync as statSync3 } from "node:fs";
 async function distributeYoutube2(mixtapeId, videoPath, onProgress) {
   const contentLength = fileSize2(videoPath);
   const contentType = "video/mp4";
@@ -3569,7 +3752,7 @@ async function resolveMixtapeId2(idOrLogId) {
 }
 function fileSize2(path2) {
   try {
-    return statSync2(path2).size;
+    return statSync3(path2).size;
   } catch {
     throw new CliError2("video_not_found", `Cannot read video file at ${path2}`);
   }
@@ -3595,9 +3778,10 @@ __export(exports_newsletter, {
   newsletterUpdateCommand: () => newsletterUpdateCommand,
   newsletterSendCommand: () => newsletterSendCommand,
   newsletterListCommand: () => newsletterListCommand,
-  newsletterDraftCommand: () => newsletterDraftCommand
+  newsletterDraftCommand: () => newsletterDraftCommand,
+  newsletterDeleteCommand: () => newsletterDeleteCommand
 });
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 function buildBody2(options, { requireContent }) {
   const body = {};
   if (options.contentFile !== undefined) {
@@ -3617,7 +3801,7 @@ function buildBody2(options, { requireContent }) {
   return body;
 }
 function readContentFile(filePath) {
-  if (!existsSync2(filePath)) {
+  if (!existsSync3(filePath)) {
     throw new CliError2("file_not_found", `Content file not found: ${filePath}`);
   }
   const text = readFileSync3(filePath, "utf-8");
@@ -3640,6 +3824,9 @@ async function newsletterListCommand() {
   const response = await adminApiGet("/api/admin/newsletter/editions");
   return response.editions;
 }
+async function newsletterDeleteCommand(id) {
+  return adminApiDelete(`/api/admin/newsletter/editions/${encodeURIComponent(id)}`);
+}
 var init_newsletter = __esm(() => {
   init_api();
   init_output();
@@ -4254,7 +4441,7 @@ var COORD_FALLBACK2 = "—";
 var init_format2 = () => {};
 
 // src/cli.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import path2 from "path";
 
 // ../../node_modules/commander/lib/error.js
@@ -6614,7 +6801,7 @@ function addAdminCommands(program2) {
     const { mixtapeGetCommand: mixtapeGetCommand3 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes));
     await runMixtapeGet(idOrLogId, options, mixtapeGetCommand3);
   });
-  adminMixtapes.command("distribute").description("Mint + push a mixtape to YouTube (video) and Mixcloud (audio)").argument("[idOrLogId]").option("--video <file>", "Video file for YouTube").option("--audio <file>", "Audio file for Mixcloud").option("--youtube", "Only distribute to YouTube").option("--mixcloud", "Only distribute to Mixcloud").option("--unlisted", "Keep Mixcloud private too (YouTube is always unlisted until publish-youtube)").option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
+  adminMixtapes.command("distribute").description("Mint + push a mixtape to YouTube (video) and Mixcloud (audio)").argument("[idOrLogId]").option("--video <file>", "Video file for YouTube").option("--audio <file>", "Audio file for Mixcloud").option("--youtube", "Only distribute to YouTube").option("--mixcloud", "Only distribute to Mixcloud").option("--set-video", "Also stage a 1080p set-video rendition (from --video) to R2 + flip setVideoAt for the /log player").option("--unlisted", "Keep Mixcloud private too (YouTube is always unlisted until publish-youtube)").option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
     const { mixtapeDistributeCommand: mixtapeDistributeCommand2 } = await Promise.resolve().then(() => (init_mixtapes2(), exports_mixtapes));
     await runMixtapeDistribute(idOrLogId, options, mixtapeDistributeCommand2);
   });
@@ -6642,6 +6829,10 @@ function addAdminCommands(program2) {
     const { newsletterListCommand: newsletterListCommand2 } = await Promise.resolve().then(() => (init_newsletter(), exports_newsletter));
     await runNewsletterList(options, newsletterListCommand2);
   });
+  adminNewsletter.command("delete").description("Delete an edition (draft or sent) \u2014 OPERATOR only; reopens the send window").argument("[id]").option("--yes", "Confirm the delete", false).option("--json", "Print JSON", false).allowExcessArguments().action(async (id, options) => {
+    const { newsletterDeleteCommand: newsletterDeleteCommand2 } = await Promise.resolve().then(() => (init_newsletter(), exports_newsletter));
+    await runNewsletterDelete(id, options, newsletterDeleteCommand2);
+  });
   const submissions = configureCommand(admin.command("submissions").description("Review listener submissions"));
   submissions.option("--json", "Print JSON", false).action(async (options) => {
     const { listSubmissionsCommand: listSubmissionsCommand2 } = await Promise.resolve().then(() => (init_submissions(), exports_submissions));
@@ -6923,7 +7114,7 @@ async function runTrackVideo(idOrLogId, options, trackVideoCommand2) {
       return;
     }
     const candidate = path2.join(dir, name);
-    return existsSync3(candidate) ? candidate : undefined;
+    return existsSync4(candidate) ? candidate : undefined;
   };
   const resolveFile = (explicit, name) => {
     if (explicit) {
@@ -7260,6 +7451,20 @@ async function runNewsletterSend(id, options, newsletterSendCommand2) {
   const number = result.edition.number;
   console.log(number === undefined ? `Sent edition ${result.edition.id}.` : `Sent edition #${number} \u2014 it's out to the list and in the archive.`);
 }
+async function runNewsletterDelete(id, options, newsletterDeleteCommand2) {
+  if (!id) {
+    throw new Error("Missing edition id. Usage: fluncle admin newsletter delete <id> --yes");
+  }
+  if (!options.yes) {
+    throw new Error("Pass --yes to confirm \u2014 this hard-deletes the edition (draft or sent).");
+  }
+  const result = await newsletterDeleteCommand2(id);
+  if (options.json) {
+    printJson({ ...result, ok: true });
+    return;
+  }
+  console.log(`Deleted edition ${result.id}. The send window reopens to cover its finds.`);
+}
 async function runNewsletterList(options, newsletterListCommand2) {
   const editions = await newsletterListCommand2();
   if (options.json) {

package/package.json

@@ -31,5 +31,5 @@
     "url": "git+https://github.com/mauricekleine/fluncle.git"
   },
   "type": "module",
-  "version": "0.68.0"
+  "version": "0.69.0"
 }