cursedbelt-server 4.42.0 → 4.43.1

package/src/server/storage/transcode.integration.spec.ts

@@ -1,4 +1,5 @@
 import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import type { Subprocess } from 'bun';
 import { existsSync, mkdirSync } from 'node:fs';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
@@ -18,11 +19,16 @@ const BS_PRESENT = BS_DIR !== '' && existsSync(path.join(BS_DIR, 'src', 'index.t
 
 // SKIPPED until a real binary-server checkout is present: point BINARY_SERVER_DIR at one.
 // There is deliberately no default — a published package must not go looking in one machine's
-// directory layout — and `binary-server` has not been re-homed here, so this skips on every host today.
+// directory layout. In this generation that checkout is `$FORGE/apps/binary-server`.
+// BS_ALLOW_NEW_STORE=1: the spawned server refuses to invent a store it was not given, and this
+// throwaway one is exactly a store it should create.
+// BS_SECRETS_FILE=/dev/null: otherwise it folds in this machine's binary-server.env — the real R2
+// keys and passcode — and a throwaway store has no business holding them.
 describe.skipIf(!BS_PRESENT)('transcode API → real binary-server (integration)', () => {
   let port: number;
   let storeDir: string;
   let server: TestServer | null = null;
+  let worker: Subprocess | null = null;
   let tmpData: string;
   const INTERNAL_SECRET = 'test-transcode-secret';
 
@@ -32,24 +38,37 @@ describe.skipIf(!BS_PRESENT)('transcode API → real binary-server (integration)
     mkdirSync(storeDir, { recursive: true });
 
     port = await pickFreePort();
+    const env = {
+      PORT: String(port),
+      HOST: '127.0.0.1',
+      STORAGE_ROOT: storeDir,
+      DB_PATH: path.join(tmpData, 'test.sqlite'),
+      BS_ALLOW_NEW_STORE: '1',
+      BS_SECRETS_FILE: '/dev/null',
+      INTERNAL_SECRET,
+      NODE_ENV: 'test',
+    };
     server = await startTestServer({
       cwd: BS_DIR,
       cmd: ['bun', path.join(BS_DIR, 'src', 'index.ts')],
       port,
-      env: {
-        PORT: String(port),
-        HOST: '127.0.0.1',
-        STORAGE_ROOT: storeDir,
-        DB_PATH: path.join(tmpData, 'test.sqlite'),
-        INTERNAL_SECRET,
-        NODE_ENV: 'test',
-      },
+      env,
       healthPath: '/healthz',
       timeoutMs: 90_000,
     });
+    // The store only ENQUEUES a job; binary-server's processing worker (its own process since
+    // bs task 2694) leases and runs it. Without one, every job stays `pending` forever.
+    worker = Bun.spawn(['bun', path.join(BS_DIR, 'src', 'processingWorker.ts')], {
+      cwd: BS_DIR,
+      env: { ...process.env, ...env },
+      stdout: 'inherit',
+      stderr: 'inherit',
+    });
   }, 90_000);
 
   afterAll(async () => {
+    worker?.kill();
+    await worker?.exited;
     await server?.stop();
     await rm(tmpData, { recursive: true, force: true }).catch(() => void 0);
   });
@@ -118,7 +137,9 @@ describe.skipIf(!BS_PRESENT)('transcode API → real binary-server (integration)
       await Bun.sleep(100);
     }
     expect(status).toBe('failed');
-  });
+    // Past bun's 5 s default: a timeout kills the spawned server, and the tests after this one
+    // then fail at `fetch` instead of here, naming the wrong thing.
+  }, 15_000);
 
   test('GET /api/transcode/:jobId returns 404 for unknown job', async () => {
     const res = await fetch(`http://localhost:${port}/api/transcode/nonexistent-job-id`, {

package/src/server/youtube/youtubeApi.spec.ts

@@ -0,0 +1,90 @@
+/**
+ * The YouTube Data API reader (forge task 2349), against a fake Google — no request leaves.
+ *
+ * What is worth pinning: a page comes out normalized (no envelope, no tombstones), every page of
+ * a playlist is walked and a cap is SAID rather than silently applied, lengths are read in
+ * batches of 50, and a refusal carries the fix rather than a bare status.
+ */
+import { describe, expect, test } from "bun:test";
+import { collectYouTubePages, createYouTubeApi, youtubeThumbnailUrl } from "./youtubeApi";
+
+type Handler = (url: URL) => { status?: number; body: unknown };
+
+const fakeGoogle = (handler: Handler) => {
+	const seen: URL[] = [];
+	const fetchImpl = async (input: string): Promise<Response> => {
+		const url = new URL(input);
+		seen.push(url);
+		const { status = 200, body } = handler(url);
+		return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+	};
+	return { seen, api: createYouTubeApi(fetchImpl) };
+};
+
+const item = (videoId: string, title = `Video ${videoId}`) => ({
+	snippet: { title, videoOwnerChannelTitle: "Chan", thumbnails: {} },
+	contentDetails: { videoId },
+});
+
+describe("createYouTubeApi", () => {
+	test("a playlist page is normalized, a tombstone is dropped, and a missing picture falls back to YouTube's", async () => {
+		const { api, seen } = fakeGoogle(() => ({
+			body: { items: [item("a1"), item("gone", "Deleted video")], nextPageToken: "p2" },
+		}));
+		const page = await api.playlistItems("tok", "PL1");
+		expect(page).toEqual({
+			status: "ok",
+			value: {
+				nextPageToken: "p2",
+				items: [
+					{
+						videoId: "a1",
+						title: "Video a1",
+						channelTitle: "Chan",
+						thumbnail: youtubeThumbnailUrl("a1"),
+						url: "https://www.youtube.com/watch?v=a1",
+					},
+				],
+			},
+		});
+		expect(seen[0]?.pathname).toBe("/youtube/v3/playlistItems");
+		expect(seen[0]?.searchParams.get("playlistId")).toBe("PL1");
+	});
+
+	test("🔴 every page is walked, and a list stopped at the cap SAYS so", async () => {
+		const { api } = fakeGoogle((url) => {
+			const at = Number(url.searchParams.get("pageToken") ?? "0");
+			return { body: { items: [item(`v${at}`)], nextPageToken: String(at + 1) } };
+		});
+		const capped = await collectYouTubePages((pt) => api.playlistItems("tok", "PL1", pt), 3);
+		expect(capped).toMatchObject({ status: "ok", truncated: true });
+		expect(capped.status === "ok" ? capped.items.map((v) => v.videoId) : []).toEqual(["v0", "v1", "v2"]);
+
+		const { api: short } = fakeGoogle(() => ({ body: { items: [item("only")] } }));
+		expect(await collectYouTubePages((pt) => short.playlistItems("tok", "PL1", pt))).toMatchObject({
+			status: "ok",
+			truncated: false,
+		});
+	});
+
+	test("lengths are read 50 ids at a time, and an ISO duration becomes seconds", async () => {
+		const { api, seen } = fakeGoogle((url) => ({
+			body: {
+				items: (url.searchParams.get("id") ?? "").split(",").map((id) => ({ id, contentDetails: { duration: "PT1H2M3S" } })),
+			},
+		}));
+		const ids = Array.from({ length: 51 }, (_, i) => `id${i}`);
+		const lengths = await api.durations("tok", ids);
+		expect(seen).toHaveLength(2);
+		expect(lengths.status === "ok" ? lengths.value.get("id50") : null).toBe(3723);
+	});
+
+	test("🔴 a refusal names the fix — a 403 says quota or API-not-enabled, a 401 says reconnect", async () => {
+		const forbidden = await fakeGoogle(() => ({ status: 403, body: { error: { message: "quotaExceeded" } } })).api.playlists("tok");
+		expect(forbidden).toMatchObject({ status: "error", reason: "YouTube refused the read: quotaExceeded" });
+		expect(forbidden.status === "error" ? forbidden.fix : "").toMatch(/quota/);
+
+		const lapsed = await fakeGoogle(() => ({ status: 401, body: {} })).api.playlists("tok");
+		expect(lapsed.status === "error" ? lapsed.fix : "").toMatch(/Connect again/);
+	});
+});

package/src/server/youtube/youtubeApi.ts

@@ -0,0 +1,325 @@
+/**
+ * `cursedbelt-server/youtube` — the YouTube Data API v3, READ half only, normalized.
+ *
+ * Arrived in 4.43.0 (forge task 2349) from Music (`apps/music/src/server/tube/youtubeApi.ts`),
+ * where it was already catalog-agnostic, so Collections could list the same owner's playlists
+ * without a second copy. Worker-safe: it is `fetch` and nothing else.
+ *
+ * 🔴 **It never writes to YouTube.** The scope a consumer asks for is
+ * {@link YOUTUBE_READONLY_SCOPE}, and there is no code path here that could create, reorder or
+ * delete anything in the owner's account. The failure mode of a write-back mistake is
+ * destroying a playlist on a service no app here owns.
+ *
+ * ── Quota ────────────────────────────────────────────────────────────────────────────────
+ * Every call costs Data API quota (10,000 units/day by default; a `playlistItems` page costs 1,
+ * a `search` 100 — which is why there is no search). Playback is not the Data API, so a
+ * consumer reads once, when the owner asks, and never on a timer.
+ *
+ * Every read that fails says why AND what to do ({@link TubeApiResult}) — the same law
+ * `./google-oauth` runs on. Normalized shapes come out, so no route and no browser ever touches
+ * a Google response envelope.
+ */
+import type { FetchLike } from "../google-oauth/googleOAuth";
+
+const API_BASE = "https://www.googleapis.com/youtube/v3";
+
+/** YouTube's own still for a video — the fallback when a playlist row carries no thumbnail. */
+export const youtubeThumbnailUrl = (videoId: string): string =>
+	videoId ? `https://i.ytimg.com/vi/${videoId}/mqdefault.jpg` : "";
+
+/** Read-only, and nothing else. See the header. */
+export const YOUTUBE_READONLY_SCOPE = "https://www.googleapis.com/auth/youtube.readonly";
+
+export interface TubeApiVideo {
+	videoId: string;
+	title: string;
+	channelTitle: string;
+	thumbnail: string;
+	url: string;
+}
+
+export interface TubeApiPlaylist {
+	id: string;
+	title: string;
+	description: string;
+	thumbnail: string;
+	itemCount: number;
+}
+
+export interface TubeApiChannel {
+	id: string;
+	title: string;
+	thumbnail: string;
+}
+
+export interface TubePage<T> {
+	items: T[];
+	nextPageToken?: string;
+}
+
+/** A read that failed says why and what to do — the same law the token store runs on. */
+export type TubeApiResult<T> =
+	| { status: "ok"; value: T }
+	| { status: "error"; reason: string; fix: string };
+
+type Json = Record<string, unknown>;
+type Thumbs = Record<string, { url?: string } | undefined> | undefined;
+
+/**
+ * `medium` first, deliberately. `default` is 120×90 and looks like a thumbnail from 2009 on
+ * a retina phone; `maxres` does not exist for most videos, so preferring it would leave
+ * half a list with no picture at all.
+ */
+const pickThumb = (thumbs: Thumbs): string =>
+	thumbs?.medium?.url || thumbs?.high?.url || thumbs?.standard?.url || thumbs?.default?.url || "";
+
+const watchUrl = (videoId: string): string => `https://www.youtube.com/watch?v=${videoId}`;
+
+/**
+ * A playlist keeps a tombstone for a video the uploader deleted or made private. It has a
+ * title and a thumbnail and NOTHING that will ever play, so importing it would put dead
+ * rows in the owner's list that look exactly like live ones until pressed.
+ */
+const UNPLAYABLE_TITLES = new Set(["Private video", "Deleted video"]);
+
+async function get(
+	accessToken: string,
+	path: string,
+	params: Record<string, string>,
+	fetchImpl: FetchLike,
+): Promise<TubeApiResult<Json>> {
+	let res: Response;
+	try {
+		res = await fetchImpl(`${API_BASE}/${path}?${new URLSearchParams(params).toString()}`, {
+			headers: { authorization: `Bearer ${accessToken}` },
+			signal: AbortSignal.timeout(30_000),
+		});
+	} catch (err) {
+		return {
+			status: "error",
+			reason: `could not reach YouTube: ${err instanceof Error ? err.message : String(err)}`,
+			fix: "check this machine's internet connection and try again",
+		};
+	}
+	const body = (await res.json().catch(() => ({}))) as Json;
+	if (!res.ok) {
+		const detail = ((body.error as Json | undefined)?.message as string) || `HTTP ${res.status}`;
+		// 403 is overwhelmingly one of two things and they have different fixes, so the
+		// message says both rather than making the owner guess which.
+		if (res.status === 403) {
+			return {
+				status: "error",
+				reason: `YouTube refused the read: ${detail}`,
+				fix: "this is either the daily Data API quota (it resets at midnight Pacific) or the YouTube Data API v3 not being enabled for this Google Cloud project",
+			};
+		}
+		return {
+			status: "error",
+			reason: `YouTube refused the read: ${detail}`,
+			fix:
+				res.status === 401
+					? "the connection has lapsed — press Disconnect and Connect again"
+					: "try again; if it persists, check the YouTube API status",
+		};
+	}
+	return { status: "ok", value: body };
+}
+
+const rows = (body: Json): Json[] => (Array.isArray(body.items) ? (body.items as Json[]) : []);
+const nextToken = (body: Json): { nextPageToken?: string } =>
+	typeof body.nextPageToken === "string" ? { nextPageToken: body.nextPageToken } : {};
+
+/** `PT1H2M3S` → 3723. YouTube's ISO 8601 durations never carry years or months. */
+function parseIsoDuration(value: string): number | null {
+	const m = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(value);
+	if (!m || value === "P" || value.endsWith("T")) return null;
+	const [, d, h, min, s] = m.map((x) => Number(x ?? 0));
+	return (d as number) * 86_400 + (h as number) * 3600 + (min as number) * 60 + (s as number);
+}
+
+export function createYouTubeApi(fetchImpl: FetchLike = fetch) {
+	return {
+		/** Who this grant belongs to — the name shown beside "Connected". */
+		async channel(accessToken: string): Promise<TubeApiResult<TubeApiChannel | null>> {
+			const res = await get(accessToken, "channels", { part: "snippet", mine: "true" }, fetchImpl);
+			if (res.status !== "ok") return res;
+			const first = rows(res.value)[0];
+			if (!first) return { status: "ok", value: null };
+			const snippet = (first.snippet as Json) ?? {};
+			return {
+				status: "ok",
+				value: {
+					id: String(first.id ?? ""),
+					title: String(snippet.title ?? ""),
+					thumbnail: pickThumb(snippet.thumbnails as Thumbs),
+				},
+			};
+		},
+
+		async playlists(
+			accessToken: string,
+			pageToken?: string,
+		): Promise<TubeApiResult<TubePage<TubeApiPlaylist>>> {
+			const res = await get(
+				accessToken,
+				"playlists",
+				{
+					part: "snippet,contentDetails",
+					mine: "true",
+					maxResults: "50",
+					...(pageToken ? { pageToken } : {}),
+				},
+				fetchImpl,
+			);
+			if (res.status !== "ok") return res;
+			return {
+				status: "ok",
+				value: {
+					...nextToken(res.value),
+					items: rows(res.value).map((p) => {
+						const snippet = (p.snippet as Json) ?? {};
+						const details = (p.contentDetails as Json) ?? {};
+						return {
+							id: String(p.id ?? ""),
+							title: String(snippet.title ?? ""),
+							description: String(snippet.description ?? ""),
+							thumbnail: pickThumb(snippet.thumbnails as Thumbs),
+							itemCount: typeof details.itemCount === "number" ? details.itemCount : 0,
+						};
+					}),
+				},
+			};
+		},
+
+		async playlistItems(
+			accessToken: string,
+			playlistId: string,
+			pageToken?: string,
+		): Promise<TubeApiResult<TubePage<TubeApiVideo>>> {
+			const res = await get(
+				accessToken,
+				"playlistItems",
+				{
+					part: "snippet,contentDetails",
+					playlistId,
+					maxResults: "50",
+					...(pageToken ? { pageToken } : {}),
+				},
+				fetchImpl,
+			);
+			if (res.status !== "ok") return res;
+			return {
+				status: "ok",
+				value: {
+					...nextToken(res.value),
+					items: rows(res.value)
+						.map((item): TubeApiVideo => {
+							const snippet = (item.snippet as Json) ?? {};
+							const details = (item.contentDetails as Json) ?? {};
+							const resource = snippet.resourceId as Json | undefined;
+							const videoId = String(details.videoId ?? resource?.videoId ?? "");
+							return {
+								videoId,
+								title: String(snippet.title ?? ""),
+								channelTitle: String(snippet.videoOwnerChannelTitle ?? ""),
+								thumbnail: pickThumb(snippet.thumbnails as Thumbs) || youtubeThumbnailUrl(videoId),
+								url: watchUrl(videoId),
+							};
+						})
+						.filter((v) => v.videoId && !UNPLAYABLE_TITLES.has(v.title)),
+				},
+			};
+		},
+
+		/**
+		 * How long each video is, in seconds — `playlistItems` does not say. Up to 50 ids per
+		 * call (1 quota unit each call), so a 200-video playlist costs four. A video YouTube no
+		 * longer returns (private since, deleted) is simply absent from the map.
+		 */
+		async durations(accessToken: string, videoIds: readonly string[]): Promise<TubeApiResult<Map<string, number>>> {
+			const out = new Map<string, number>();
+			for (let at = 0; at < videoIds.length; at += 50) {
+				const res = await get(
+					accessToken,
+					"videos",
+					{ part: "contentDetails", id: videoIds.slice(at, at + 50).join(","), maxResults: "50" },
+					fetchImpl,
+				);
+				if (res.status !== "ok") return res;
+				for (const v of rows(res.value)) {
+					const seconds = parseIsoDuration(String((v.contentDetails as Json)?.duration ?? ""));
+					if (seconds !== null) out.set(String(v.id ?? ""), seconds);
+				}
+			}
+			return { status: "ok", value: out };
+		},
+
+		/**
+		 * Liked videos. Not a playlist read: the "LL" pseudo-playlist is not reliably
+		 * listable through `playlistItems`, whereas `videos?myRating=like` is the documented
+		 * way to ask and costs the same.
+		 */
+		async liked(
+			accessToken: string,
+			pageToken?: string,
+		): Promise<TubeApiResult<TubePage<TubeApiVideo>>> {
+			const res = await get(
+				accessToken,
+				"videos",
+				{
+					part: "snippet",
+					myRating: "like",
+					maxResults: "50",
+					...(pageToken ? { pageToken } : {}),
+				},
+				fetchImpl,
+			);
+			if (res.status !== "ok") return res;
+			return {
+				status: "ok",
+				value: {
+					...nextToken(res.value),
+					items: rows(res.value)
+						.map((v): TubeApiVideo => {
+							const snippet = (v.snippet as Json) ?? {};
+							const videoId = String(v.id ?? "");
+							return {
+								videoId,
+								title: String(snippet.title ?? ""),
+								channelTitle: String(snippet.channelTitle ?? ""),
+								thumbnail: pickThumb(snippet.thumbnails as Thumbs) || youtubeThumbnailUrl(videoId),
+								url: watchUrl(videoId),
+							};
+						})
+						.filter((v) => v.videoId),
+				},
+			};
+		},
+	};
+}
+
+export type YouTubeApi = ReturnType<typeof createYouTubeApi>;
+
+/**
+ * Walk every page of a paginated read, stopping at `maxPages` and SAYING SO (`truncated`).
+ *
+ * A list that quietly stops at the cap is indistinguishable from one that is exactly that long,
+ * so the cap is reported. 40 pages of 50 is 2,000 videos — larger than any real playlist, and
+ * small enough that a pathological account cannot turn one button into a thousand API calls.
+ */
+export async function collectYouTubePages<T>(
+	fetchPage: (pageToken?: string) => Promise<TubeApiResult<TubePage<T>>>,
+	maxPages = 40,
+): Promise<{ status: "ok"; items: T[]; truncated: boolean } | { status: "error"; reason: string; fix: string }> {
+	const items: T[] = [];
+	let pageToken: string | undefined;
+	let pages = 0;
+	do {
+		const page = await fetchPage(pageToken);
+		if (page.status !== "ok") return page;
+		items.push(...page.value.items);
+		pageToken = page.value.nextPageToken;
+		pages += 1;
+	} while (pageToken && pages < maxPages);
+	return { status: "ok", items, truncated: Boolean(pageToken) };
+}