shorts-maker 0.3.0

package/src/social/config.ts

@@ -0,0 +1,72 @@
+// Local, gitignored store for social-media credentials (config/social.json).
+
+import { join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { CONFIG_DIR } from "../paths.ts";
+
+const CONFIG_FILE = join(CONFIG_DIR, "social.json");
+
+export interface FacebookConfig {
+  pageId: string;
+  token: string;
+  pageName?: string;
+}
+
+export interface SocialConfig {
+  facebook?: FacebookConfig;
+}
+
+async function read(): Promise<SocialConfig> {
+  const f = Bun.file(CONFIG_FILE);
+  if (!(await f.exists())) return {};
+  try {
+    return JSON.parse(await f.text()) as SocialConfig;
+  } catch {
+    return {};
+  }
+}
+
+async function write(cfg: SocialConfig): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await Bun.write(CONFIG_FILE, JSON.stringify(cfg, null, 2));
+}
+
+export const getConfig = read;
+
+export async function getFacebook(): Promise<FacebookConfig | undefined> {
+  return (await read()).facebook;
+}
+
+/** Tokens never contain whitespace/quotes — strip anything a copy-paste dragged in. */
+export function cleanToken(raw: string): string {
+  return raw.replace(/\s+/g, "").replace(/^["']+|["']+$/g, "");
+}
+
+/**
+ * Merge-save the Facebook config. A blank/absent token keeps the existing one, so the
+ * user can change the Page ID without re-entering the token. Changing anything clears
+ * the cached page name until re-verified.
+ */
+export async function saveFacebook(patch: { pageId: string; token?: string }): Promise<void> {
+  const cfg = await read();
+  const prev = cfg.facebook;
+  const cleaned = patch.token ? cleanToken(patch.token) : "";
+  const token = cleaned || prev?.token || "";
+  cfg.facebook = { pageId: patch.pageId.trim(), token, pageName: undefined };
+  await write(cfg);
+}
+
+/** Remember the verified page name so the settings page can show it without a round-trip. */
+export async function setFacebookPageName(pageName: string): Promise<void> {
+  const cfg = await read();
+  if (cfg.facebook) {
+    cfg.facebook.pageName = pageName;
+    await write(cfg);
+  }
+}
+
+export async function clearFacebook(): Promise<void> {
+  const cfg = await read();
+  delete cfg.facebook;
+  await write(cfg);
+}

package/src/social/facebook.ts

@@ -0,0 +1,232 @@
+// Facebook Page publishing via the Graph API.
+
+// Single place to bump the Graph API version. v25.0 is the latest live version and
+// matches Facebook's video-publishing guide.
+const API_VERSION = "v25.0";
+const GRAPH = `https://graph.facebook.com/${API_VERSION}`;
+const GRAPH_VIDEO = `https://graph-video.facebook.com/${API_VERSION}`;
+
+export class FacebookError extends Error {}
+
+interface GraphError {
+  error?: { message?: string; type?: string; code?: number; error_subcode?: number };
+}
+
+/** Parse a Graph response body defensively — FB can return `null`, empty, or non-JSON. */
+async function readJson<T>(res: Response): Promise<T> {
+  const data = await res.json().catch(() => null);
+  return (data && typeof data === "object" ? data : {}) as T;
+}
+
+/** Build a helpful message from Facebook's error object. */
+function fbMessage(err: GraphError["error"], status: number): string {
+  if (!err) return `Graph API returned ${status}.`;
+  let msg = err.message || `Graph API returned ${status}.`;
+  if (err.code) msg += ` (code ${err.code}${err.error_subcode ? `/${err.error_subcode}` : ""})`;
+  if (/session has expired|expired/i.test(err.message ?? "")) {
+    msg += " — this token has expired. Generate a fresh one (and extend it to long-lived).";
+  } else if (/malformed|cannot parse|invalid oauth access token data/i.test(err.message ?? "")) {
+    msg += " — the token looks malformed. Re-copy it as a single line with no spaces.";
+  }
+  return msg;
+}
+
+/** Permissions the token needs to publish a video to a Page. */
+const REQUIRED_PERMISSIONS = ["pages_manage_posts"];
+
+/** Read the token's granted permissions via debug_token (null if it can't be determined). */
+async function tokenScopes(token: string): Promise<string[] | null> {
+  try {
+    const url = `${GRAPH}/debug_token?input_token=${encodeURIComponent(token)}&access_token=${encodeURIComponent(token)}`;
+    const res = await fetch(url);
+    const data = await readJson<{ data?: { scopes?: string[]; granular_scopes?: { scope: string }[] } }>(res);
+    if (!data?.data) return null;
+    const scopes = new Set(data.data.scopes ?? []);
+    for (const g of data.data.granular_scopes ?? []) scopes.add(g.scope);
+    return scopes.size ? [...scopes] : null;
+  } catch {
+    return null;
+  }
+}
+
+export interface VerifyResult {
+  pageName: string;
+  /** Required publishing permissions the token is missing (empty if OK or undeterminable). */
+  missing: string[];
+}
+
+/** Verify the token + page (name + publishing permissions). Fails loudly with FB's message. */
+export async function verify(pageId: string, token: string): Promise<VerifyResult> {
+  if (!pageId || !token) throw new FacebookError("Page ID and access token are both required.");
+  const url = `${GRAPH}/${encodeURIComponent(pageId)}?fields=name&access_token=${encodeURIComponent(token)}`;
+  const res = await fetch(url);
+  const data = await readJson<GraphError & { name?: string }>(res);
+  if (!res.ok || data.error) throw new FacebookError(fbMessage(data.error, res.status));
+  if (!data.name) throw new FacebookError("Could not read the page name — check the Page ID.");
+
+  const scopes = await tokenScopes(token);
+  const missing = scopes ? REQUIRED_PERMISSIONS.filter((p) => !scopes.includes(p)) : [];
+  return { pageName: data.name, missing };
+}
+
+/** Look up a nice permalink for a freshly-uploaded video (best-effort). */
+async function permalink(videoId: string, token: string): Promise<string | undefined> {
+  try {
+    const url = `${GRAPH}/${videoId}?fields=permalink_url&access_token=${encodeURIComponent(token)}`;
+    const res = await fetch(url);
+    const data = await readJson<{ permalink_url?: string }>(res);
+    if (data.permalink_url) {
+      return data.permalink_url.startsWith("http")
+        ? data.permalink_url
+        : `https://www.facebook.com${data.permalink_url}`;
+    }
+  } catch {
+    /* ignore — the id alone is enough */
+  }
+  return undefined;
+}
+
+/** Delete a Page video (removes the post). */
+export async function deleteVideo(videoId: string, token: string): Promise<void> {
+  const url = `${GRAPH}/${encodeURIComponent(videoId)}?access_token=${encodeURIComponent(token)}`;
+  const res = await fetch(url, { method: "DELETE" });
+  const data = await readJson<GraphError & { success?: boolean }>(res);
+  if (data.error) throw new FacebookError(fbMessage(data.error, res.status));
+  if (!data.success) throw new FacebookError(`Delete failed (HTTP ${res.status}).`);
+}
+
+/** Comment on a post/video as the Page (needs `pages_manage_engagement`). */
+export async function postComment(objectId: string, message: string, token: string): Promise<{ id: string }> {
+  const form = new FormData();
+  form.append("access_token", token);
+  form.append("message", message);
+  const res = await fetch(`${GRAPH}/${encodeURIComponent(objectId)}/comments`, { method: "POST", body: form });
+  const data = await readJson<GraphError & { id?: string }>(res);
+  if (data.error) throw new FacebookError(fbMessage(data.error, res.status));
+  if (!data.id) throw new FacebookError(`Comment failed (HTTP ${res.status}).`);
+  return { id: data.id };
+}
+
+/** Edit an existing Page comment in place. */
+export async function updateComment(commentId: string, message: string, token: string): Promise<void> {
+  const form = new FormData();
+  form.append("access_token", token);
+  form.append("message", message);
+  const res = await fetch(`${GRAPH}/${encodeURIComponent(commentId)}`, { method: "POST", body: form });
+  const data = await readJson<GraphError & { success?: boolean }>(res);
+  if (data.error) throw new FacebookError(fbMessage(data.error, res.status));
+  if (!data.success) throw new FacebookError(`Comment update failed (HTTP ${res.status}).`);
+}
+
+/** Delete a Page comment. */
+export async function deleteComment(commentId: string, token: string): Promise<void> {
+  const url = `${GRAPH}/${encodeURIComponent(commentId)}?access_token=${encodeURIComponent(token)}`;
+  const res = await fetch(url, { method: "DELETE" });
+  const data = await readJson<GraphError & { success?: boolean }>(res);
+  if (data.error) throw new FacebookError(fbMessage(data.error, res.status));
+}
+
+export interface UploadResult {
+  id: string;
+  url?: string;
+}
+
+interface UploadOpts {
+  pageId: string;
+  token: string;
+  filePath: string;
+  title?: string;
+  description: string;
+  /** Called as bytes land on Facebook, for a live progress bar. */
+  onProgress?: (sent: number, total: number) => void;
+}
+
+/**
+ * Publish a local video to the Page via Facebook's chunked video upload
+ * (`upload_phase = start → transfer… → finish` on the `/<page-id>/videos` edge).
+ * Facebook dictates each chunk's byte range, so there are no oversized requests and no
+ * guessed chunk sizes. This is the long-standing Page path; the newer Resumable Upload
+ * API (`/uploads` + `fbuploader_video_file_chunk`) consistently failed ingest here with
+ * code 6000/1363019 even for valid files, so we deliberately avoid it.
+ * Docs: developers.facebook.com/docs/graph-api/reference/page/videos/
+ */
+export async function uploadVideo(opts: UploadOpts): Promise<UploadResult> {
+  const file = Bun.file(opts.filePath);
+  if (!(await file.exists())) throw new FacebookError("The clip file is missing on disk.");
+  const size = file.size;
+  const url = `${GRAPH_VIDEO}/${encodeURIComponent(opts.pageId)}/videos`;
+
+  const post = async <T>(fields: Record<string, string | Blob>): Promise<T & GraphError> => {
+    const form = new FormData();
+    form.append("access_token", opts.token);
+    for (const [k, v] of Object.entries(fields)) form.append(k, v);
+    const res = await fetch(url, {
+      method: "POST",
+      body: form,
+      signal: AbortSignal.timeout(10 * 60_000), // don't hang forever on a stalled socket
+    });
+    return readJson<T & GraphError>(res);
+  };
+
+  // 1) start → Facebook opens a session and tells us which bytes it wants first.
+  const start = await post<{ upload_session_id?: string; video_id?: string; start_offset?: string; end_offset?: string }>(
+    { upload_phase: "start", file_size: String(size) },
+  );
+  if (start.error) throw new FacebookError(fbMessage(start.error, 200));
+  const sessionId = start.upload_session_id;
+  const videoId = start.video_id;
+  if (!sessionId || !videoId) throw new FacebookError("Couldn’t start the upload session.");
+
+  // 2) transfer — until Facebook reports both offsets equal (everything received).
+  //    Its hinted ranges are tiny (~1–5 MB), and a 300 MB clip in 1 MB chunks pays
+  //    hundreds of sequential round-trips; verified empirically that it happily accepts
+  //    (and fully consumes) chunks far larger than the hint, so we send 32 MB at a time
+  //    and only drop back to the exact hinted range while retrying after a failure.
+  //    Error 1363037 even tells us where to resume.
+  const CHUNK = 32 * 1024 * 1024;
+  let from = Number(start.start_offset ?? 0);
+  let to = Number(start.end_offset ?? 0);
+  let retries = 0;
+  opts.onProgress?.(0, size);
+  while (from < to) {
+    const sendTo = retries > 0 ? to : Math.min(Math.max(to, from + CHUNK), size);
+    const chunk = await post<{ start_offset?: string; end_offset?: string }>({
+      upload_phase: "transfer",
+      upload_session_id: sessionId,
+      start_offset: String(from),
+      video_file_chunk: file.slice(from, sendTo),
+    }).catch((e) => ({ error: { message: (e as Error).message } }) as GraphError & { start_offset?: string; end_offset?: string });
+
+    if (chunk.error) {
+      // error_data on 1363037 carries the offset to resume from.
+      const resume = (chunk.error as { error_data?: { start_offset?: string } }).error_data?.start_offset;
+      if (resume !== undefined) from = Number(resume);
+      if (++retries > 5) throw new FacebookError(fbMessage(chunk.error, 200));
+      await Bun.sleep(Math.min(1500 * 2 ** retries, 15_000));
+      continue;
+    }
+    retries = 0;
+    from = Number(chunk.start_offset ?? sendTo);
+    to = Number(chunk.end_offset ?? sendTo);
+    opts.onProgress?.(Math.min(from, size), size);
+  }
+
+  // 3) finish — attach the caption and publish. `success` may be false without an error
+  //    object on rare hiccups, so retry that too.
+  for (let attempt = 0; ; attempt++) {
+    const fin = await post<{ success?: boolean }>({
+      upload_phase: "finish",
+      upload_session_id: sessionId,
+      description: opts.description,
+      ...(opts.title ? { title: opts.title } : {}),
+    });
+    if (fin.success) break;
+    if (attempt >= 3) {
+      throw new FacebookError(fin.error ? fbMessage(fin.error, 200) : "Facebook didn’t confirm the publish.");
+    }
+    await Bun.sleep(2500 * (attempt + 1));
+  }
+  opts.onProgress?.(size, size);
+
+  return { id: videoId, url: await permalink(videoId, opts.token) };
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "jsx": "react-jsx",
+    "types": ["bun-types"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "verbatimModuleSyntax": true
+  },
+  "include": ["src", "frontend"]
+}