mirror of
https://github.com/4gray/iptvnator.git
synced 2026-10-09 01:16:15 -08:00
4gray
93e759e1da
* fix(m3u): accept standard Base64 ClearKey values * refactor(release): move M3U fixture generation out of capture driver
518 lines
19 KiB
TypeScript
518 lines
19 KiB
TypeScript
/**
|
|
* App driving for capture-release-screenshots.ts: launch, readiness, demo
|
|
* seeding, theme switching, and the named setup actions the manifest refers
|
|
* to. Mechanics proven in the v0.20 capture run, generalized behind action
|
|
* names.
|
|
*/
|
|
|
|
import { spawn, type ChildProcess } from 'node:child_process';
|
|
import { mkdirSync } from 'node:fs';
|
|
import path from 'node:path';
|
|
import {
|
|
_electron as electron,
|
|
type ElectronApplication,
|
|
type Page,
|
|
} from '@playwright/test';
|
|
|
|
import {
|
|
STALKER_FIXTURE_MAC,
|
|
STALKER_FIXTURE_PORTAL_URL,
|
|
STALKER_FIXTURE_TITLE,
|
|
STALKER_MOCK_ORIGIN,
|
|
XTREAM_FIXTURE_CREDENTIALS,
|
|
XTREAM_FIXTURE_TITLE,
|
|
XTREAM_MOCK_ORIGIN,
|
|
XTREAM_SECONDARY_FIXTURE_CREDENTIALS,
|
|
XTREAM_SECONDARY_FIXTURE_TITLE,
|
|
} from './capture-fixtures';
|
|
import {
|
|
clickDialogOption,
|
|
openAddPlaylistDialog,
|
|
registerPlaylistId,
|
|
requirePlaylistId,
|
|
} from './capture-navigation';
|
|
import type { PlaylistProvider } from './capture-navigation';
|
|
|
|
export {
|
|
M3U_FIXTURE_TITLE,
|
|
XTREAM_FIXTURE_TITLE,
|
|
XTREAM_MOCK_ORIGIN,
|
|
writeM3uFixture,
|
|
} from './capture-fixtures';
|
|
|
|
/**
|
|
* Synthetic categories that only the marketing fixture generator produces,
|
|
* per catalog. They must be checked against their OWN endpoint: a series
|
|
* category can never appear in `get_vod_categories`, and asserting it there
|
|
* made the reuse path below reject every already-running mock.
|
|
*/
|
|
const MOCK_FIXTURE_CATEGORIES: ReadonlyArray<{
|
|
action: 'get_vod_categories' | 'get_series_categories';
|
|
name: string;
|
|
}> = [
|
|
{ action: 'get_vod_categories', name: 'Action & Mystery' },
|
|
{ action: 'get_series_categories', name: 'Urban Drama' },
|
|
];
|
|
/**
|
|
* Live categories of the Stalker mock's marketing-demo scenario, from
|
|
* `MARKETING_LIVE_CATEGORIES` in `@iptvnator/shared/marketing-fixtures`.
|
|
* Spelled out here because `pnpm release:screenshots` runs tsx without the
|
|
* base tsconfig, so workspace path aliases do not resolve in this file.
|
|
*/
|
|
const STALKER_MOCK_FIXTURE_CATEGORIES = ['Newsroom', 'Culture & Docs'];
|
|
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* Fixtures */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
export async function ensureXtreamMockServer(
|
|
workspaceRoot: string
|
|
): Promise<ChildProcess | undefined> {
|
|
const healthUrl = `${XTREAM_MOCK_ORIGIN}/health`;
|
|
|
|
// Reusing whatever answers on the port is not enough: every guard treats
|
|
// localhost as trusted, so an unrelated local server or proxy could feed
|
|
// real catalog data and artwork straight into published screenshots.
|
|
// Require the marketing fixtures this capture is built around.
|
|
if (await isHealthy(healthUrl)) {
|
|
await assertMockServerIdentity();
|
|
return undefined;
|
|
}
|
|
|
|
const child = spawn(
|
|
path.join(workspaceRoot, 'node_modules/.bin/tsx'),
|
|
// The mock server imports `@iptvnator/shared/marketing-fixtures`, and
|
|
// tsx only resolves that path alias when pointed at the base config —
|
|
// matching how the project's own serve target invokes it.
|
|
[
|
|
'--tsconfig',
|
|
'tsconfig.base.json',
|
|
'apps/xtream-mock-server/src/main.ts',
|
|
],
|
|
{
|
|
cwd: workspaceRoot,
|
|
env: { ...process.env, NODE_ENV: 'development', PORT: '3211' },
|
|
stdio: ['ignore', 'pipe', 'pipe'],
|
|
}
|
|
);
|
|
|
|
child.stderr?.on('data', (chunk) =>
|
|
process.stderr.write(`[xtream-mock] ${chunk}`)
|
|
);
|
|
|
|
const deadline = Date.now() + 20_000;
|
|
|
|
while (Date.now() < deadline) {
|
|
if (await isHealthy(healthUrl)) {
|
|
return child;
|
|
}
|
|
await sleep(500);
|
|
}
|
|
|
|
child.kill('SIGTERM');
|
|
throw new Error(`xtream-mock-server did not become healthy at ${healthUrl}`);
|
|
}
|
|
|
|
export async function ensureStalkerMockServer(
|
|
workspaceRoot: string
|
|
): Promise<ChildProcess | undefined> {
|
|
const healthUrl = `${STALKER_MOCK_ORIGIN}/health`;
|
|
|
|
if (await isHealthy(healthUrl)) {
|
|
await assertStalkerMockServerIdentity();
|
|
return undefined;
|
|
}
|
|
|
|
const child = spawn(
|
|
path.join(workspaceRoot, 'node_modules/.bin/tsx'),
|
|
['--tsconfig', 'tsconfig.base.json', 'apps/stalker-mock-server/src/main.ts'],
|
|
{
|
|
cwd: workspaceRoot,
|
|
env: { ...process.env, NODE_ENV: 'development', PORT: '3210' },
|
|
stdio: ['ignore', 'pipe', 'pipe'],
|
|
}
|
|
);
|
|
|
|
child.stderr?.on('data', (chunk) =>
|
|
process.stderr.write(`[stalker-mock] ${chunk}`)
|
|
);
|
|
|
|
const deadline = Date.now() + 20_000;
|
|
|
|
while (Date.now() < deadline) {
|
|
if (await isHealthy(healthUrl)) {
|
|
return child;
|
|
}
|
|
await sleep(500);
|
|
}
|
|
|
|
child.kill('SIGTERM');
|
|
throw new Error(`stalker-mock-server did not become healthy at ${healthUrl}`);
|
|
}
|
|
|
|
/**
|
|
* Same trust boundary as the Xtream check: whatever answers on the Stalker
|
|
* port must serve the marketing-demo scenario's fictional live categories.
|
|
*/
|
|
async function assertStalkerMockServerIdentity(): Promise<void> {
|
|
const response = await fetch(
|
|
`${STALKER_MOCK_ORIGIN}/portal.php?type=itv&action=get_genres&JsHttpRequest=1-xml`,
|
|
{ headers: { Cookie: `mac=${STALKER_FIXTURE_MAC}; stb_lang=en; timezone=UTC` } }
|
|
).catch(() => null);
|
|
|
|
if (!response?.ok) {
|
|
throw new Error(
|
|
`Something is listening on ${STALKER_MOCK_ORIGIN} but does not answer the Stalker portal API — stop it and let this script start the mock server itself.`
|
|
);
|
|
}
|
|
|
|
const payload = (await response.json().catch(() => null)) as
|
|
| { js?: { title?: string }[] }
|
|
| null;
|
|
const titles = new Set((payload?.js ?? []).map((entry) => entry.title));
|
|
|
|
for (const expected of STALKER_MOCK_FIXTURE_CATEGORIES) {
|
|
if (!titles.has(expected)) {
|
|
throw new Error(
|
|
`The server on ${STALKER_MOCK_ORIGIN} is not the IPTVnator marketing mock (missing live category "${expected}"). Refusing to capture screenshots from unknown data.`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Confirms the service on the mock port is our fixture server: it must serve
|
|
* the marketing catalog with the exact synthetic titles the shots rely on.
|
|
*/
|
|
async function assertMockServerIdentity(): Promise<void> {
|
|
for (const expected of MOCK_FIXTURE_CATEGORIES) {
|
|
const response = await fetch(
|
|
`${XTREAM_MOCK_ORIGIN}/player_api.php?username=marketing&password=marketing&action=${expected.action}`
|
|
).catch(() => null);
|
|
|
|
if (!response?.ok) {
|
|
throw new Error(
|
|
`Something is listening on ${XTREAM_MOCK_ORIGIN} but does not answer the Xtream marketing API — stop it and let this script start the mock server itself.`
|
|
);
|
|
}
|
|
|
|
const categories = (await response.json().catch(() => null)) as
|
|
| { category_name?: string }[]
|
|
| null;
|
|
const names = new Set(
|
|
(categories ?? []).map((entry) => entry.category_name)
|
|
);
|
|
|
|
if (!names.has(expected.name)) {
|
|
throw new Error(
|
|
`The server on ${XTREAM_MOCK_ORIGIN} is not the IPTVnator marketing mock (missing ${expected.action} entry "${expected.name}"). Refusing to capture screenshots from unknown data.`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
async function isHealthy(url: string): Promise<boolean> {
|
|
try {
|
|
return (await fetch(url)).ok;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* Launch and readiness */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
/**
|
|
* Replaces Electron's native folder picker with one that answers `folder`
|
|
* (created here) — the same trick `downloads.e2e.ts` uses. The downloads
|
|
* page's "Change Folder" button then authorizes a folder inside the isolated
|
|
* data dir, so guide shots never write into the real OS Downloads folder.
|
|
*/
|
|
export async function installDownloadFolderDialogStub(
|
|
app: ElectronApplication,
|
|
folder: string
|
|
): Promise<void> {
|
|
mkdirSync(folder, { recursive: true });
|
|
await app.evaluate(({ dialog }, target) => {
|
|
dialog.showOpenDialog = async () =>
|
|
({
|
|
canceled: false,
|
|
filePaths: [target],
|
|
}) as Awaited<ReturnType<typeof dialog.showOpenDialog>>;
|
|
}, folder);
|
|
}
|
|
|
|
export async function launchApp(
|
|
electronMainPath: string,
|
|
env: Record<string, string>,
|
|
hostResolverRules: string
|
|
): Promise<ElectronApplication> {
|
|
// The resolver switch is the only part of the network gate with no
|
|
// install-timing window: it takes effect before Electron runs a single
|
|
// line of app code, so startup traffic cannot slip through ahead of the
|
|
// session hook.
|
|
return electron.launch({
|
|
args: [
|
|
electronMainPath,
|
|
`--host-resolver-rules=${hostResolverRules}`,
|
|
],
|
|
env,
|
|
});
|
|
}
|
|
|
|
export async function findMainWindow(app: ElectronApplication): Promise<Page> {
|
|
await sleep(1500);
|
|
|
|
for (const candidate of app.windows()) {
|
|
if (!(await candidate.title()).includes('DevTools')) {
|
|
return candidate;
|
|
}
|
|
}
|
|
|
|
return app.firstWindow();
|
|
}
|
|
|
|
export async function sizeWindow(
|
|
app: ElectronApplication,
|
|
viewport: { width: number; height: number }
|
|
): Promise<void> {
|
|
await app.evaluate(({ BrowserWindow }, size) => {
|
|
const win = BrowserWindow.getAllWindows().find(
|
|
(candidate) => !candidate.webContents.getTitle().includes('DevTools')
|
|
);
|
|
win?.setSize(size.width, size.height);
|
|
win?.center();
|
|
}, viewport);
|
|
}
|
|
|
|
export async function waitForAppReady(page: Page): Promise<void> {
|
|
await page.waitForLoadState('domcontentloaded');
|
|
await page.waitForSelector('app-root', { timeout: 45_000 });
|
|
await page.waitForFunction(
|
|
() =>
|
|
(document.querySelector('app-root')?.innerHTML.trim().length ?? 0) >
|
|
0,
|
|
{ timeout: 45_000 }
|
|
);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* Seeding */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
export interface SeedOptions {
|
|
/** Also add the Stalker marketing portal (guide shots only: it changes the dashboard). */
|
|
stalker?: boolean;
|
|
/**
|
|
* Also add the second marketing Xtream source (guide shots only). Its
|
|
* catalog is identical to the first, which is what makes the movie detail
|
|
* show a Sources chip.
|
|
*/
|
|
secondaryXtream?: boolean;
|
|
}
|
|
|
|
export async function seedDemoData(
|
|
page: Page,
|
|
m3uPath: string,
|
|
options: SeedOptions = {}
|
|
): Promise<void> {
|
|
await addXtreamPortal(page, {
|
|
title: XTREAM_FIXTURE_TITLE,
|
|
credentials: XTREAM_FIXTURE_CREDENTIALS,
|
|
provider: 'xtreams',
|
|
});
|
|
await addM3uPlaylist(page, m3uPath);
|
|
if (options.stalker) {
|
|
await addStalkerPortal(page);
|
|
}
|
|
if (options.secondaryXtream) {
|
|
await addXtreamPortal(page, {
|
|
title: XTREAM_SECONDARY_FIXTURE_TITLE,
|
|
credentials: XTREAM_SECONDARY_FIXTURE_CREDENTIALS,
|
|
provider: 'xtreams-secondary',
|
|
});
|
|
// Multi-source discovery reads the SQLite content table, which the
|
|
// desktop data source fills per category on first view. Open the
|
|
// category the guide shot walks into so its movies are cached before
|
|
// the primary portal's detail page looks for alternatives.
|
|
await page
|
|
.locator('app-workspace-context-panel .category-item')
|
|
.filter({ hasText: 'Action & Mystery' })
|
|
.first()
|
|
.click();
|
|
await page
|
|
.locator('.category-content-layout mat-card')
|
|
.first()
|
|
.waitFor({ state: 'visible', timeout: 30_000 });
|
|
}
|
|
await seedDashboardActivity(page);
|
|
}
|
|
|
|
/**
|
|
* The dashboard hero and rails only render with favorites/recent activity.
|
|
* Seed a handful of mock titles through the Electron DB bridge; backdrops
|
|
* point at the mock server, keeping G3/G4 satisfied.
|
|
*/
|
|
async function seedDashboardActivity(page: Page): Promise<void> {
|
|
const playlistId = requirePlaylistId('xtreams');
|
|
const backdrop = (title: string) =>
|
|
`${XTREAM_MOCK_ORIGIN}/assets/marketing/backdrop/${title
|
|
.toLowerCase()
|
|
.replace(/[^a-z0-9]+/g, '-')}.svg?size=${encodeURIComponent('1280x720')}`;
|
|
// Xtream VOD stream ids are assigned by array position
|
|
// (`MARKETING_VOD_STREAM_ID_BASE + index` in marketing.generator.ts), and
|
|
// the generator lists POSTER_SHOWCASE_MOVIES first. Keep these three titles
|
|
// in step with the first three entries of that fixture list, otherwise the
|
|
// seeded backdrops belong to different movies than the ids resolve to.
|
|
const items = [
|
|
{ xtreamId: 62000, type: 'movie', backdropUrl: backdrop('Black Harbor'), recent: true },
|
|
{ xtreamId: 62001, type: 'movie', backdropUrl: backdrop('The Paper Astronaut'), recent: true },
|
|
{ xtreamId: 62002, type: 'movie', backdropUrl: backdrop('Summer Static'), recent: false },
|
|
{ xtreamId: 72000, type: 'series', backdropUrl: backdrop('Skyline Sentinels'), recent: true },
|
|
{ xtreamId: 72001, type: 'series', backdropUrl: backdrop('The Aegis Club'), recent: false },
|
|
] as const;
|
|
|
|
await page.evaluate(
|
|
async ({ items, playlistId }) => {
|
|
const bridge = (
|
|
window as typeof window & {
|
|
electron?: {
|
|
dbAddFavorite?: (contentId: number, playlistId: string, backdropUrl?: string) => Promise<unknown>;
|
|
dbAddRecentItem?: (contentId: number, playlistId: string, backdropUrl?: string) => Promise<unknown>;
|
|
dbGetContentByXtreamId?: (
|
|
xtreamId: number,
|
|
playlistId: string,
|
|
contentType?: 'live' | 'movie' | 'series'
|
|
) => Promise<{ id: number } | null>;
|
|
};
|
|
}
|
|
).electron;
|
|
|
|
if (!bridge?.dbGetContentByXtreamId) {
|
|
throw new Error('Electron database bridge is unavailable.');
|
|
}
|
|
|
|
for (const item of items) {
|
|
const content = await bridge.dbGetContentByXtreamId(
|
|
item.xtreamId,
|
|
playlistId,
|
|
item.type
|
|
);
|
|
|
|
if (!content?.id) {
|
|
throw new Error(
|
|
`Could not find imported Xtream content ${item.xtreamId}.`
|
|
);
|
|
}
|
|
|
|
await bridge.dbAddFavorite?.(content.id, playlistId, item.backdropUrl);
|
|
|
|
if (item.recent) {
|
|
await bridge.dbAddRecentItem?.(content.id, playlistId, item.backdropUrl);
|
|
}
|
|
}
|
|
},
|
|
{ items, playlistId }
|
|
);
|
|
}
|
|
|
|
interface XtreamPortalSeed {
|
|
title: string;
|
|
credentials: { readonly username: string; readonly password: string };
|
|
provider: PlaylistProvider;
|
|
}
|
|
|
|
async function addXtreamPortal(
|
|
page: Page,
|
|
seed: XtreamPortalSeed
|
|
): Promise<void> {
|
|
await openAddPlaylistDialog(page);
|
|
const dialog = page.locator('mat-dialog-container').last();
|
|
|
|
await clickDialogOption(dialog, /xtream credentials/i);
|
|
await dialog.locator('#title').fill(seed.title);
|
|
await dialog.locator('#serverUrl').fill(XTREAM_MOCK_ORIGIN);
|
|
await dialog.locator('#username').fill(seed.credentials.username);
|
|
await dialog.locator('#password').fill(seed.credentials.password);
|
|
await dialog
|
|
.getByRole('button', { name: /^(add|add playlist)$/i })
|
|
.last()
|
|
.click();
|
|
await dialog.waitFor({ state: 'detached', timeout: 30_000 });
|
|
await page.waitForURL(/\/workspace\/xtreams\/[^/]+\/vod/, {
|
|
timeout: 45_000,
|
|
});
|
|
registerPlaylistId(seed.provider, idFromUrl(page.url(), 'xtreams'));
|
|
await page
|
|
.locator('.category-content-layout, app-content-card')
|
|
.first()
|
|
.waitFor({ state: 'visible', timeout: 45_000 });
|
|
}
|
|
|
|
async function addStalkerPortal(page: Page): Promise<void> {
|
|
await openAddPlaylistDialog(page);
|
|
const dialog = page.locator('mat-dialog-container').last();
|
|
|
|
await clickDialogOption(dialog, /stalker portal/i);
|
|
await dialog.locator('#title').fill(STALKER_FIXTURE_TITLE);
|
|
await dialog.locator('#portalUrl').fill(STALKER_FIXTURE_PORTAL_URL);
|
|
await dialog.locator('#macAddress').fill(STALKER_FIXTURE_MAC);
|
|
// Endpoint discovery probes the mock before the row is written.
|
|
await dialog.getByRole('button', { name: /^add$/i }).last().click();
|
|
await dialog.waitFor({ state: 'detached', timeout: 60_000 });
|
|
await page.waitForURL(/\/workspace\/stalker\/[^/]+\/vod/, {
|
|
timeout: 60_000,
|
|
});
|
|
registerPlaylistId('stalker', idFromUrl(page.url(), 'stalker'));
|
|
await page
|
|
.locator('.category-content-layout, app-content-card')
|
|
.first()
|
|
.waitFor({ state: 'visible', timeout: 45_000 });
|
|
}
|
|
|
|
async function addM3uPlaylist(page: Page, m3uPath: string): Promise<void> {
|
|
await openAddPlaylistDialog(page);
|
|
const dialog = page.locator('mat-dialog-container').last();
|
|
|
|
// Unanchored: the radio's accessible name concatenates title + subtitle.
|
|
await clickDialogOption(dialog, /m3u file/i);
|
|
|
|
const fileInput = dialog.locator('input[type="file"][name="playlist"]');
|
|
await fileInput.setInputFiles(m3uPath);
|
|
await dialog
|
|
.getByRole('button', { name: /add playlist/i })
|
|
.last()
|
|
.click({ timeout: 15_000 });
|
|
await dialog.waitFor({ state: 'detached', timeout: 30_000 });
|
|
await page.waitForURL(/\/workspace\/playlists\/[^/]+\/all/, {
|
|
timeout: 45_000,
|
|
});
|
|
registerPlaylistId('playlists', idFromUrl(page.url(), 'playlists'));
|
|
await page
|
|
.locator('[data-test-id="channel-item"]')
|
|
.first()
|
|
.waitFor({ state: 'visible', timeout: 60_000 });
|
|
}
|
|
|
|
function idFromUrl(url: string, provider: PlaylistProvider): string {
|
|
// `provider` is a closed union, but build the pattern from a literal
|
|
// anyway so no future caller can inject regex syntax through it.
|
|
const pattern =
|
|
provider === 'playlists'
|
|
? /\/workspace\/playlists\/([^/]+)\//
|
|
: provider === 'xtreams'
|
|
? /\/workspace\/xtreams\/([^/]+)\//
|
|
: /\/workspace\/stalker\/([^/]+)\//;
|
|
const match = url.match(pattern);
|
|
|
|
if (!match) {
|
|
throw new Error(`Could not extract ${provider} id from ${url}`);
|
|
}
|
|
|
|
return match[1];
|
|
}
|