npm - shorts-maker - Versions diffs - 0.3.0 → 0.4.0 - Mend

shorts-maker 0.3.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/index.html CHANGED Viewed

@@ -10,7 +10,7 @@
       type="image/svg+xml"
       href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Cdefs%3E%3ClinearGradient id='g' x1='0' y1='0' x2='1' y2='1'%3E%3Cstop offset='0' stop-color='%237c5cff'/%3E%3Cstop offset='1' stop-color='%232dd4bf'/%3E%3C/linearGradient%3E%3C/defs%3E%3Crect width='32' height='32' rx='8' fill='url(%23g)'/%3E%3Cg transform='translate(6.5 6.5) scale(0.79)' fill='none' stroke='white' stroke-width='2.4' stroke-linecap='round' stroke-linejoin='round'%3E%3Ccircle cx='6' cy='6' r='3'/%3E%3Ccircle cx='6' cy='18' r='3'/%3E%3Cline x1='20' y1='4' x2='8.12' y2='15.88'/%3E%3Cline x1='14.47' y1='14.48' x2='20' y2='20'/%3E%3Cline x1='8.12' y1='8.12' x2='12' y2='12'/%3E%3C/g%3E%3C/svg%3E"
     />
-  <link rel="stylesheet" crossorigin href="/chunk-wt9saz7q.css"><script type="module" crossorigin src="/chunk-27wzf6kd.js"></script></head>
+  <link rel="stylesheet" crossorigin href="/chunk-1w58sy4p.css"><script type="module" crossorigin src="/chunk-23ted1q8.js"></script></head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "shorts-maker",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Split a video into consecutive shorts titled from its name, add hashtags, and publish them to Facebook — runs locally in your browser.",
   "type": "module",
   "module": "src/server.ts",

package/src/pipeline/pipeline.ts CHANGED Viewed

@@ -90,7 +90,11 @@ export interface PublishInfo {
   /** Upload progress while `pending`: bytes transferred so far, and the total. */
   sent?: number;
   total?: number;
-  /** Id of this post's "All parts" index comment, so it can be edited as parts land. */
+  /**
+   * Id of the Page comment written on this post from the job page's comment dialog, so a
+   * later run edits it in place instead of adding a second one. (Named for the "All parts"
+   * index it used to serve, which the dialog replaced.)
+   */
   indexCommentId?: string;
   /** When this state was last set (ms epoch). */
   at: number;

package/src/server.ts CHANGED Viewed

@@ -4,7 +4,7 @@
 import { join, basename, extname, dirname } from "node:path";
 import { readdir, mkdir, rm } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { hashtagPool } from "./pipeline/pipeline.ts";
+import { hashtagPool, type PublishInfo } from "./pipeline/pipeline.ts";
 import { isOverlayPosition, OVERLAY_POSITIONS } from "./pipeline/overlay.ts";
 import * as store from "./jobs/store.ts";
 import * as social from "./social/config.ts";
@@ -138,72 +138,11 @@ async function handleFbTest(req: Request): Promise<Response> {
   }
 }
-/**
- * Keep one "All parts" index comment on every posted part, edited in place as parts are
- * published or removed. With fewer than two posts an index is noise, so any leftover
- * index comment is deleted instead.
- */
-async function syncPartsIndex(
-  job: store.Job,
-  platform: string,
-  token: string,
-): Promise<{ updated: number; warnings: string[] }> {
-  const published = job.parts
-    .filter((p) => p.published?.[platform]?.status === "done" && p.published[platform]!.id)
-    .sort((a, b) => a.part - b.part);
-  const warnings: string[] = [];
-  let updated = 0;
-  if (published.length < 2) {
-    for (const p of published) {
-      const pub = p.published![platform]!;
-      if (!pub.indexCommentId) continue;
-      await facebook.deleteComment(pub.indexCommentId, token).catch(() => {});
-      store.setPublishState(job.id, p.file, platform, { ...pub, indexCommentId: undefined });
-    }
-    return { updated, warnings };
-  }
-  // Footer flips automatically once the final part lands, since comments are re-edited
-  // on every sync.
-  const complete = published.length === job.parts.length;
-  const footer = complete
-    ? "❤️ Enjoyed the series? Follow us for more content!"
-    : "🔔 Follow us — more parts coming soon!";
-  const message =
-    "📺 All parts:\n" +
-    published
-      .map((p) => {
-        const pub = p.published![platform]!;
-        return `▶ Part ${p.part}: ${pub.url ?? `https://www.facebook.com/${pub.id}`}`;
-      })
-      .join("\n") +
-    `\n\n${footer}`;
-  for (const p of published) {
-    const pub = p.published![platform]!;
-    try {
-      if (pub.indexCommentId) {
-        await facebook.updateComment(pub.indexCommentId, message, token);
-      } else {
-        const c = await facebook.postComment(pub.id!, message, token);
-        store.setPublishState(job.id, p.file, platform, { ...pub, indexCommentId: c.id });
-      }
-      updated++;
-    } catch (err) {
-      warnings.push(`Part ${p.part}: ${(err as Error).message}`);
-    }
-  }
-  return { updated, warnings };
-}
 async function handlePublish(req: Request): Promise<Response> {
   const body = (await req.json().catch(() => null)) as {
     jobId?: string;
     file?: string;
     platform?: string;
-    /** Maintain an "All parts" index comment on every posted part of this series. */
-    linkAll?: boolean;
   } | null;
   const jobId = body?.jobId ?? "";
   const file = body?.file ?? "";
@@ -242,24 +181,7 @@ async function handlePublish(req: Request): Promise<Response> {
     });
     const info = { status: "done" as const, id: res.id, url: res.url, at: Date.now() };
     store.setPublishState(jobId, file, platform, info);
-    // Series index: refresh the "All parts" comment across every posted part.
-    // Best-effort — the publish itself already succeeded, so index trouble is reported
-    // as a warning, never as a failed publish.
-    let indexed: number | undefined;
-    let linkWarning: string | undefined;
-    if (body?.linkAll) {
-      const sync = await syncPartsIndex(job, platform, fb.token);
-      indexed = sync.updated;
-      if (sync.warnings.length) linkWarning = `Index comment issues — ${sync.warnings.join("; ")}`;
-    }
-    return json({
-      ok: true,
-      platform,
-      ...info,
-      ...(indexed !== undefined ? { indexed } : {}),
-      ...(linkWarning ? { linkWarning } : {}),
-    });
+    return json({ ok: true, platform, ...info });
   } catch (err) {
     const msg = (err as Error).message;
     store.setPublishState(jobId, file, platform, { status: "error", error: msg, at: Date.now() });
@@ -267,6 +189,163 @@ async function handlePublish(req: Request): Promise<Response> {
   }
 }
+/** A comment Facebook no longer has — editing it must fall back to writing a fresh one. */
+const commentGone = (msg: string) => /does not exist|cannot be loaded|unsupported get request|missing/i.test(msg);
+/**
+ * Comment on several of a job's published parts at once.
+ *
+ * A part whose post already carries this app's comment (`indexCommentId`) has it edited in
+ * place; otherwise a fresh comment is written and its id stored, so the next run edits that
+ * one instead of piling up copies.
+ *
+ * Each part is attempted independently: one Page/rate-limit failure must not hide the
+ * comments that did land, so every outcome comes back per-part rather than as a single throw.
+ */
+async function handleComment(req: Request): Promise<Response> {
+  const body = (await req.json().catch(() => null)) as {
+    jobId?: string;
+    files?: string[];
+    platform?: string;
+    message?: string;
+  } | null;
+  const platform = body?.platform ?? "facebook";
+  if (platform !== "facebook") return json({ error: `Unsupported platform: ${platform}` }, 400);
+  const message = (body?.message ?? "").trim();
+  if (!message) return json({ error: "A comment message is required." }, 400);
+  const job = store.get(body?.jobId ?? "");
+  if (!job) return json({ error: "No such job." }, 404);
+  const files = Array.isArray(body?.files) ? body.files.map(String) : [];
+  if (!files.length) return json({ error: "Pick at least one published part." }, 400);
+  const fb = await social.getFacebook();
+  if (!fb?.pageId || !fb?.token) {
+    return json({ error: "Facebook isn’t configured. Add your Page in Settings." }, 400);
+  }
+  type Result = { file: string; part?: number; ok: boolean; id?: string; action?: "created" | "updated"; error?: string };
+  const results: Result[] = [];
+  /** Write a new comment on the post and remember its id, so the next run edits it. */
+  const create = async (file: string, postId: string, pub: PublishInfo): Promise<Result> => {
+    const c = await facebook.postComment(postId, message, fb.token);
+    store.setPublishState(job.id, file, platform, { ...pub, indexCommentId: c.id });
+    return { file, ok: true, id: c.id, action: "created" };
+  };
+  for (const file of files) {
+    const part = job.parts.find((p) => p.file === file);
+    const pub = part?.published?.[platform];
+    if (!part || pub?.status !== "done" || !pub.id) {
+      results.push({ file, part: part?.part, ok: false, error: "This part isn’t posted." });
+      continue;
+    }
+    try {
+      if (pub.indexCommentId) {
+        try {
+          await facebook.updateComment(pub.indexCommentId, message, fb.token);
+          results.push({ file, part: part.part, ok: true, id: pub.indexCommentId, action: "updated" });
+        } catch (err) {
+          // Someone deleted it on Facebook's side — write a fresh one and re-track it.
+          if (!commentGone((err as Error).message)) throw err;
+          results.push({ ...(await create(file, pub.id, pub)), part: part.part });
+        }
+      } else {
+        results.push({ ...(await create(file, pub.id, pub)), part: part.part });
+      }
+    } catch (err) {
+      results.push({ file, part: part.part, ok: false, error: (err as Error).message });
+    }
+  }
+  const posted = results.filter((r) => r.ok).length;
+  return json({ ok: posted === results.length, posted, results });
+}
+/**
+ * Reconcile the tracked comment ids against what's actually on Facebook, without writing
+ * anything to the Page. For each published part we list the comments its post carries that
+ * were authored by our Page, then:
+ *
+ *   - the tracked comment is still there            → "tracked" (nothing to do)
+ *   - it's gone, or we never had one, and exactly
+ *     one Page comment exists                       → "linked" (adopt it)
+ *   - several Page comments exist and none is
+ *     tracked                                       → "ambiguous" (adopt nothing, list them)
+ *   - the Page has commented nothing                → "none"
+ *
+ * The ambiguous case is deliberately left alone: guessing wrong would mean the next comment
+ * silently overwrites the wrong one. The candidates come back so the user can decide.
+ */
+async function handleSyncComments(req: Request): Promise<Response> {
+  const body = (await req.json().catch(() => null)) as { jobId?: string; platform?: string } | null;
+  const platform = body?.platform ?? "facebook";
+  if (platform !== "facebook") return json({ error: `Unsupported platform: ${platform}` }, 400);
+  const job = store.get(body?.jobId ?? "");
+  if (!job) return json({ error: "No such job." }, 404);
+  const fb = await social.getFacebook();
+  if (!fb?.pageId || !fb?.token) {
+    return json({ error: "Facebook isn’t configured. Add your Page in Settings." }, 400);
+  }
+  type Status = "tracked" | "linked" | "ambiguous" | "none";
+  const results: {
+    file: string;
+    part: number;
+    status?: Status;
+    ok: boolean;
+    commentId?: string;
+    candidates?: facebook.PageComment[];
+    error?: string;
+  }[] = [];
+  for (const part of job.parts) {
+    const pub = part.published?.[platform];
+    if (pub?.status !== "done" || !pub.id) continue; // not posted — nothing to reconcile
+    try {
+      const mine = await facebook.listPageComments(pub.id, fb.pageId, fb.token);
+      const tracked = pub.indexCommentId && mine.some((c) => c.id === pub.indexCommentId);
+      let status: Status;
+      let commentId: string | undefined;
+      if (tracked) {
+        status = "tracked";
+        commentId = pub.indexCommentId;
+      } else if (mine.length === 1) {
+        status = "linked";
+        commentId = mine[0]!.id;
+      } else if (mine.length > 1) {
+        status = "ambiguous";
+      } else {
+        status = "none";
+      }
+      // Adopt the found comment; drop a tracked id that no longer exists on the Page.
+      if (commentId !== pub.indexCommentId) {
+        store.setPublishState(job.id, part.file, platform, { ...pub, indexCommentId: commentId });
+      }
+      results.push({
+        file: part.file,
+        part: part.part,
+        ok: true,
+        status,
+        commentId,
+        ...(status === "ambiguous" ? { candidates: mine } : {}),
+      });
+    } catch (err) {
+      results.push({ file: part.file, part: part.part, ok: false, error: (err as Error).message });
+    }
+  }
+  if (!results.length) return json({ error: "No published parts to sync." }, 400);
+  return json({ ok: results.every((r) => r.ok), results });
+}
 /** Delete the Facebook post for a part, then forget the local publish record. */
 async function handleUnpublish(req: Request): Promise<Response> {
   const body = (await req.json().catch(() => null)) as { jobId?: string; file?: string; platform?: string } | null;
@@ -290,14 +369,10 @@ async function handleUnpublish(req: Request): Promise<Response> {
       return json({ error: msg }, 502);
     }
   }
+  // Deleting the post takes its comment with it, so the local record (comment id included)
+  // is simply forgotten. Comments on the *other* posts may now list a dead link — reposting
+  // from the job page's comment dialog rewrites them with the current parts.
   store.clearPublishState(jobId, file, platform);
-  // If this series maintains "All parts" index comments, scrub the dead link from the
-  // remaining posts (best-effort — the removal itself already succeeded).
-  const job = store.get(jobId);
-  if (job && job.parts.some((p) => p.published?.[platform]?.indexCommentId)) {
-    await syncPartsIndex(job, platform, fb.token).catch(() => {});
-  }
   return json({ ok: true });
 }
@@ -583,6 +658,8 @@ const server = Bun.serve({
       }
       if (pathname === "/api/publish" && req.method === "POST") return handlePublish(req);
       if (pathname === "/api/publish" && req.method === "DELETE") return handleUnpublish(req);
+      if (pathname === "/api/comment" && req.method === "POST") return handleComment(req);
+      if (pathname === "/api/comment/sync" && req.method === "POST") return handleSyncComments(req);
       if (pathname === "/api/uploads" && req.method === "GET") return handleListUploads();
       if (pathname === "/api/uploads" && req.method === "DELETE") return handleClearUploads();

package/src/social/facebook.ts CHANGED Viewed

@@ -107,6 +107,46 @@ export async function postComment(objectId: string, message: string, token: stri
   return { id: data.id };
 }
+export interface PageComment {
+  id: string;
+  message: string;
+  createdTime?: string;
+}
+interface CommentNode {
+  id: string;
+  message?: string;
+  created_time?: string;
+  from?: { id?: string };
+}
+/**
+ * Every comment on `objectId` authored by the Page itself, oldest first. Read-only.
+ *
+ * `from` is only populated for comments the token's Page owns, so a comment with no `from`
+ * is somebody else's and is skipped — we must never adopt a viewer's comment as our own.
+ * Paging is capped: a post with thousands of comments isn't worth walking, and our comment
+ * (posted by us, right after publishing) sits near the front.
+ */
+export async function listPageComments(objectId: string, pageId: string, token: string): Promise<PageComment[]> {
+  let url =
+    `${GRAPH}/${encodeURIComponent(objectId)}/comments` +
+    `?fields=id,message,created_time,from&order=chronological&limit=100&access_token=${encodeURIComponent(token)}`;
+  const found: PageComment[] = [];
+  for (let page = 0; page < 5 && url; page++) {
+    const res = await fetch(url);
+    const data = await readJson<GraphError & { data?: CommentNode[]; paging?: { next?: string } }>(res);
+    if (data.error) throw new FacebookError(fbMessage(data.error, res.status));
+    for (const c of data.data ?? []) {
+      if (c.from?.id !== pageId) continue;
+      found.push({ id: c.id, message: c.message ?? "", createdTime: c.created_time });
+    }
+    url = data.paging?.next ?? "";
+  }
+  return found;
+}
 /** Edit an existing Page comment in place. */
 export async function updateComment(commentId: string, message: string, token: string): Promise<void> {
   const form = new FormData();