@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/src/publish/tiktok.ts

@@ -0,0 +1,202 @@
+import { ComplianceError, RetryableError } from "@vfrey/contracts";
+import { buildTikTokInit } from "@vfrey/contracts";
+import { planTikTokChunks } from "@vfrey/contracts";
+import type { PlatformSession } from "@vfrey/contracts";
+import { requestJson } from "@vfrey/contracts";
+import { assertBucket, markBucket } from "./rate.js";
+import { ConfigError, QualityError } from "@vfrey/contracts";
+import { classifyReason, fileSize, idle, putFile, skipped, uploadFailure, type PublishContext } from "./session.js";
+
+export async function publishTikTok(ctx: PublishContext): Promise<PlatformSession> {
+  const account = ctx.account.platforms.tiktok;
+  if (!account?.enabled) return skipped();
+  const session = idle(ctx.session);
+  if (ctx.dryRun) {
+    const plan = planTikTokChunks(fileSize(ctx.filePath));
+    const built = buildTikTokInit({
+      caption: `${ctx.content.caption} ${ctx.content.hashtags.join(" ")}`.trim(),
+      privacyLevel: account.privacyLevel,
+      disableComment: account.disableComment,
+      coverTimestampMs: Math.min(ctx.content.plan.coverTimestampMs, Math.floor(ctx.content.durationSec * 1000) - 1),
+      brandContent: account.brandContent,
+      brandOrganic: account.brandOrganic,
+      videoSize: plan.videoSize,
+      chunkSize: plan.chunkSize,
+      totalChunkCount: plan.totalChunkCount,
+      audited: ctx.config.tiktok.clientAudited,
+      privacyOptions: ctx.config.tiktok.clientAudited
+        ? ["PUBLIC_TO_EVERYONE", "MUTUAL_FOLLOW_FRIENDS", "FOLLOWER_OF_CREATOR", "SELF_ONLY"]
+        : ["SELF_ONLY"],
+    });
+    session.disclosure = built.proof;
+    session.phase = "done";
+    session.externalId = "dry-run";
+    return session;
+  }
+  const size = fileSize(ctx.filePath);
+  const plan = planTikTokChunks(size);
+  if (!session.externalId) {
+    assertBucket({
+      store: ctx.store,
+      bucket: `tiktok:init:${ctx.account.id}`,
+      limit: 5,
+      windowMs: 60_000,
+      now: ctx.now,
+      code: "tiktok_init_rate",
+    });
+    const creator = await requestJson(ctx.fetchImpl, "https://open.tiktokapis.com/v2/post/publish/creator_info/query/", {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${ctx.token}`,
+        "content-type": "application/json; charset=UTF-8",
+      },
+      body: "{}",
+    });
+    if (creator.status === 429) throw new RetryableError("tiktok_rate", "TikTok creator_info rate limit");
+    if (creator.status >= 400) throw uploadFailure("tiktok", creator.status, creator.text);
+    const creatorBody = creator.json as {
+      data?: {
+        privacy_level_options?: string[];
+        comment_disabled?: boolean;
+        duet_disabled?: boolean;
+        stitch_disabled?: boolean;
+        max_video_post_duration_sec?: number;
+      };
+      error?: { code?: string; message?: string; log_id?: string };
+    };
+    if (creatorBody.error && creatorBody.error.code && creatorBody.error.code !== "ok") {
+      throw tiktokError(creatorBody.error.code, creatorBody.error.message ?? "", creatorBody.error.log_id);
+    }
+    const options = creatorBody.data?.privacy_level_options ?? [];
+    const maxDuration = creatorBody.data?.max_video_post_duration_sec ?? 600;
+    if (ctx.content.durationSec > maxDuration) {
+      throw new ComplianceError(
+        "tiktok_duration",
+        `Video is ${ctx.content.durationSec}s and this creator's max is ${maxDuration}s.`,
+      );
+    }
+    const built = buildTikTokInit({
+      caption: `${ctx.content.caption} ${ctx.content.hashtags.join(" ")}`.trim(),
+      privacyLevel: account.privacyLevel,
+      disableComment: account.disableComment || creatorBody.data?.comment_disabled === true,
+      coverTimestampMs: Math.min(ctx.content.plan.coverTimestampMs, Math.max(0, Math.floor(ctx.content.durationSec * 1000) - 1)),
+      brandContent: account.brandContent,
+      brandOrganic: account.brandOrganic,
+      videoSize: plan.videoSize,
+      chunkSize: plan.chunkSize,
+      totalChunkCount: plan.totalChunkCount,
+      audited: ctx.config.tiktok.clientAudited,
+      privacyOptions: options,
+    });
+    if (creatorBody.data?.duet_disabled) built.body.post_info.disable_duet = true;
+    if (creatorBody.data?.stitch_disabled) built.body.post_info.disable_stitch = true;
+    session.disclosure = built.proof;
+    const init = await requestJson(ctx.fetchImpl, "https://open.tiktokapis.com/v2/post/publish/video/init/", {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${ctx.token}`,
+        "content-type": "application/json; charset=UTF-8",
+      },
+      body: JSON.stringify(built.body),
+    });
+    const initBody = init.json as {
+      data?: { publish_id?: string; upload_url?: string };
+      error?: { code?: string; message?: string; log_id?: string };
+    };
+    session.logId = initBody.error?.log_id ?? null;
+    if (init.status === 429 || initBody.error?.code === "rate_limit_exceeded") {
+      throw new RetryableError("tiktok_rate", "TikTok init rate limit");
+    }
+    if (initBody.error?.code && initBody.error.code !== "ok") {
+      throw tiktokError(initBody.error.code, initBody.error.message ?? init.text, initBody.error.log_id);
+    }
+    if (!initBody.data?.publish_id || !initBody.data.upload_url) {
+      throw new RetryableError("tiktok_init", "TikTok init returned no publish_id");
+    }
+    session.externalId = initBody.data.publish_id;
+    session.uploadUrl = initBody.data.upload_url;
+    session.phase = "initialized";
+    markBucket(ctx.store, `tiktok:init:${ctx.account.id}`, ctx.now);
+    ctx.checkpoint?.(session);
+  }
+  if (session.phase === "initialized" && session.uploadUrl) {
+    let index = 0;
+    for (const range of plan.ranges) {
+      if (session.uploadedBytes > range.last) {
+        index += 1;
+        continue;
+      }
+      const result = await putFile(ctx.fetchImpl, session.uploadUrl, ctx.filePath, {
+        method: "PUT",
+        headers: {
+          "content-type": "video/mp4",
+          "content-length": String(range.size),
+          "content-range": `bytes ${range.first}-${range.last}/${plan.videoSize}`,
+        },
+        offset: range.first,
+        length: range.size,
+        idleMs: ctx.uploadIdleMs,
+      });
+      const expected = index === plan.ranges.length - 1 ? 201 : 206;
+      if (result.status !== expected && result.status !== 201) {
+        throw new RetryableError("tiktok_chunk", `TikTok chunk HTTP ${result.status}`);
+      }
+      session.uploadedBytes = range.last + 1;
+      ctx.checkpoint?.(session);
+      index += 1;
+    }
+    session.phase = "uploaded";
+    ctx.checkpoint?.(session);
+  }
+  const status = await requestJson(ctx.fetchImpl, "https://open.tiktokapis.com/v2/post/publish/status/fetch/", {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${ctx.token}`,
+      "content-type": "application/json; charset=UTF-8",
+    },
+    body: JSON.stringify({ publish_id: session.externalId }),
+  });
+  const statusBody = status.json as {
+    data?: { status?: string; publicaly_available_post_id?: string[]; fail_reason?: string };
+    error?: { code?: string; log_id?: string };
+  };
+  session.logId = statusBody.error?.log_id ?? session.logId;
+  const state = statusBody.data?.status ?? "";
+  if (state === "FAILED") {
+    throw tiktokFailed(session, statusBody.data?.fail_reason ?? "");
+  }
+  if (state !== "PUBLISH_COMPLETE" && state !== "SEND_TO_USER_INBOX") {
+    throw new RetryableError("tiktok_processing", `TikTok status ${state || "unknown"}`, 20_000);
+  }
+  session.externalId = statusBody.data?.publicaly_available_post_id?.[0] ?? session.externalId;
+  session.phase = "done";
+  return session;
+}
+
+function tiktokError(code: string, message: string, logId?: string): Error {
+  const retryable = new Set(["rate_limit_exceeded", "internal_error", "spam_risk_too_many_posts"]);
+  const suffix = logId ? ` log_id=${logId}` : "";
+  if (code === "spam_risk_too_many_posts" || code === "reached_active_user_cap") {
+    return new RetryableError(code, `${message}${suffix}`, 6 * 60 * 60_000);
+  }
+  if (retryable.has(code)) return new RetryableError(code, `${message}${suffix}`);
+  return new ComplianceError(code, `${message}${suffix}`);
+}
+
+/** A FAILED publish is classed by its fail_reason. An unknown reason fails closed as compliance. */
+function tiktokFailed(session: PlatformSession, reason: string): Error {
+  const message = `TikTok publish failed: ${reason || "no reason given"}`;
+  const code = reason ? `tiktok_${reason}`.replace(/[^\w]/g, "") : "tiktok_failed";
+  if (reason === "spam_risk_too_many_posts" || reason === "reached_active_user_cap") {
+    return new RetryableError(code, message, 6 * 60 * 60_000);
+  }
+  if (reason === "internal") {
+    // TikTok did not publish this id. The session keeps its ids and the video is never uploaded again for this job:
+    // a fresh session could race a late publish of the first one. Make a new video to try again.
+    return new QualityError("tiktok_internal", `${message}. The upload is not started again for this video.`);
+  }
+  const klass = classifyReason(reason);
+  if (klass === "quality") return new QualityError(code, message);
+  if (klass === "config") return new ConfigError(code, message);
+  return new ComplianceError(code, message);
+}

package/src/publish/youtube.ts

@@ -0,0 +1,177 @@
+import { ComplianceError, RetryableError } from "@vfrey/contracts";
+import { buildYouTubeMetadata } from "@vfrey/contracts";
+import type { PlatformSession } from "@vfrey/contracts";
+import { requestJson } from "@vfrey/contracts";
+import { assertBucket, markBucket, msUntilPacificMidnight, pacificDay } from "./rate.js";
+import { fileSize, idle, putFile, reasonOf, skipped, uploadFailure, type PublishContext } from "./session.js";
+
+export async function publishYouTube(ctx: PublishContext): Promise<PlatformSession> {
+  const account = ctx.account.platforms.youtube;
+  if (!account?.enabled) return skipped();
+  const session = idle(ctx.session);
+  const notify = account.notifySubscribers ?? ctx.account.cadence.maxPostsPerDay <= 1;
+  const built = buildYouTubeMetadata({
+    title: ctx.content.title,
+    description: `${ctx.content.description}\n\n${ctx.content.hashtags.join(" ")}`,
+    tags: ctx.content.hashtags,
+    categoryId: account.categoryId,
+    privacyStatus: account.privacyStatus,
+    madeForKids: account.madeForKids,
+    language: ctx.account.language,
+  });
+  session.disclosure = built.proof;
+  if (ctx.dryRun) {
+    session.phase = "done";
+    session.externalId = "dry-run";
+    return session;
+  }
+  const clientId = ctx.env[account.clientIdEnv] ?? "project";
+  const hadUploadUrl = Boolean(session.uploadUrl);
+  // YouTube's quota resets at Pacific midnight, so the bucket is the Pacific day.
+  const bucket = `youtube:uploads:${clientId}:${pacificDay(ctx.now)}`;
+  if (!session.uploadUrl) {
+    assertBucket({
+      store: ctx.store,
+      bucket,
+      limit: ctx.config.youtube.dailyUploadCap,
+      windowMs: 24 * 60 * 60 * 1000,
+      now: ctx.now,
+      code: "youtube_upload_cap",
+      retryAfterMs: msUntilPacificMidnight(ctx.now) + 60_000,
+    });
+    const init = await requestJson(
+      ctx.fetchImpl,
+      `https://www.googleapis.com/upload/youtube/v3/videos?uploadType=resumable&part=snippet,status&notifySubscribers=${notify}`,
+      {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${ctx.token}`,
+          "content-type": "application/json; charset=UTF-8",
+          "x-upload-content-type": "video/mp4",
+          "x-upload-content-length": String(fileSize(ctx.filePath)),
+        },
+        body: JSON.stringify(built.body),
+        timeoutMs: 60_000,
+      },
+    );
+    if (init.status === 403) {
+      const { reason } = reasonOf(init.text);
+      if (reason === "uploadLimitExceeded") {
+        throw new RetryableError("youtube_upload_limit", "YouTube's daily upload limit for this channel is reached", 24 * 60 * 60_000);
+      }
+      if (reason && /^(quotaExceeded|rateLimitExceeded|dailyLimitExceeded|userRateLimitExceeded)$/.test(reason)) {
+        throw new RetryableError("youtube_quota", "YouTube refused the upload session: quota", 60 * 60_000);
+      }
+    }
+    if (init.status >= 400) throw uploadFailure("youtube", init.status, init.text);
+    const location = init.headers.get("location");
+    if (!location) throw new RetryableError("youtube_upload", "Resumable session returned no Location");
+    session.uploadUrl = location;
+    session.phase = "initialized";
+    markBucket(ctx.store, bucket, ctx.now);
+    ctx.checkpoint?.(session);
+  }
+  const size = fileSize(ctx.filePath);
+  let offset = session.uploadedBytes;
+  // Probe every session this call did not create, including a 0-byte checkpoint.
+  // A 308 and a finished body with no video id both leave that checkpoint; only the probe reads Range.
+  if (hadUploadUrl && session.uploadUrl) {
+    const probed = await youtubeProbe(ctx.fetchImpl, session.uploadUrl, size, ctx.token);
+    if (probed.videoId) {
+      session.externalId = probed.videoId;
+      session.uploadedBytes = size;
+      confirmDisclosure(ctx, session, probed.resource);
+      session.phase = "done";
+      ctx.checkpoint?.(session);
+      return session;
+    }
+    if (probed.offset >= size) {
+      throw new RetryableError("youtube_upload", "YouTube reported the upload complete without a video id");
+    }
+    if (probed.offset > offset) offset = probed.offset;
+  }
+  const uploaded = await putFile(ctx.fetchImpl, session.uploadUrl!, ctx.filePath, {
+    method: "PUT",
+    headers: {
+      authorization: `Bearer ${ctx.token}`,
+      "content-type": "video/mp4",
+      "content-length": String(size - offset),
+      "content-range": `bytes ${offset}-${size - 1}/${size}`,
+    },
+    offset,
+    length: size - offset,
+    idleMs: ctx.uploadIdleMs,
+  });
+  if (uploaded.status === 308) {
+    session.uploadedBytes = offset;
+    ctx.checkpoint?.(session);
+    throw new RetryableError("youtube_upload", "YouTube resumable upload is incomplete");
+  }
+  if (uploaded.status >= 400) throw uploadFailure("youtube", uploaded.status, uploaded.text);
+  session.phase = "uploaded";
+  session.uploadedBytes = size;
+  const id = parseVideoId(uploaded.text);
+  if (!id) throw new RetryableError("youtube_upload", "YouTube upload finished without a video id");
+  session.externalId = id;
+  ctx.checkpoint?.(session);
+  confirmDisclosure(ctx, session, safeParse(uploaded.text));
+  session.phase = "done";
+  ctx.checkpoint?.(session);
+  return session;
+}
+
+/**
+ * The video exists now. If the returned resource does not say it is marked as synthetic, record a
+ * compliance failure and keep the video id on the session so nothing uploads it again.
+ */
+function confirmDisclosure(ctx: PublishContext, session: PlatformSession, resource: unknown): void {
+  const flag = (resource as { status?: { containsSyntheticMedia?: boolean } } | null)?.status?.containsSyntheticMedia;
+  if (flag === true) return;
+  ctx.checkpoint?.(session);
+  throw new ComplianceError(
+    "youtube_disclosure_unconfirmed",
+    `YouTube video ${session.externalId ?? ""} came back without status.containsSyntheticMedia = true. The altered-content disclosure is not confirmed.`,
+  );
+}
+
+function safeParse(text: string): unknown {
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+async function youtubeProbe(
+  fetchImpl: typeof fetch,
+  url: string,
+  size: number,
+  token: string,
+): Promise<{ offset: number; videoId: string | null; resource?: unknown }> {
+  const result = await requestJson(fetchImpl, url, {
+    method: "PUT",
+    headers: {
+      authorization: `Bearer ${token}`,
+      "content-length": "0",
+      "content-range": `bytes */${size}`,
+    },
+  });
+  if (result.status === 308) {
+    const range = result.headers.get("range");
+    const match = /bytes=0-(\d+)/.exec(range ?? "");
+    return { offset: match ? Number(match[1]) + 1 : 0, videoId: null };
+  }
+  if (result.status >= 200 && result.status < 300) {
+    return { offset: size, videoId: (result.json as { id?: string } | null)?.id ?? null, resource: result.json };
+  }
+  return { offset: 0, videoId: null };
+}
+
+function parseVideoId(text: string): string | null {
+  try {
+    const json = JSON.parse(text) as { id?: string };
+    return json.id ?? null;
+  } catch {
+    return null;
+  }
+}