@mkterswingman/5mghost-yonder 0.0.2 → 0.0.4

package/dist/download/downloader.js

@@ -0,0 +1,264 @@
+import { mkdir, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { downloadSubtitlesForLanguages, toReadableSubtitleJobError } from "../tools/subtitles.js";
+import { loadConfig } from "../utils/config.js";
+import { hasFfmpeg, isRuntimeMissingMessage } from "../utils/ffmpeg.js";
+import { formatBytes } from "../utils/formatters.js";
+import { hasYtDlp, runYtDlp, runYtDlpJson } from "../utils/ytdlp.js";
+import { parseYtDlpProgressLine } from "../utils/ytdlpProgress.js";
+export async function downloadOneItem(input) {
+    const deps = resolveDeps(input.deps);
+    const manager = input.jobManager;
+    const jobId = input.jobId;
+    const videoQuality = normalizeVideoQuality(input.videoQuality);
+    const subtitleFormats = [...input.subtitleFormats];
+    const usingDefaultSubtitleLanguages = input.subtitleLanguages == null;
+    const subtitleLanguages = [...(input.subtitleLanguages ?? input.defaultSubtitleLanguages ?? loadConfig().default_languages)];
+    const metadataFile = join(input.item.output_dir, "metadata.json");
+    const subtitlesDir = join(input.item.output_dir, "subtitles");
+    const videoFile = join(input.item.output_dir, "video.mp4");
+    let currentStep = "metadata";
+    try {
+        assertManagerInput(manager, jobId);
+        manager?.startItem(jobId, input.item.video_id, currentStep);
+        if (!deps.hasYtDlp()) {
+            throw new Error(isRuntimeMissingMessage("yt-dlp"));
+        }
+        if (needsVideo(input.mode) && !deps.hasFfmpeg()) {
+            throw new Error(isRuntimeMissingMessage("ffmpeg"));
+        }
+        // Why: reruns intentionally reuse the same YYYY-MM-DD_<video_id> directory, so stale artifacts must be cleared first.
+        await deps.rm(input.item.output_dir, { recursive: true, force: true });
+        await deps.mkdir(input.item.output_dir, { recursive: true });
+        await deps.mkdir(subtitlesDir, { recursive: true });
+        const metadata = await deps.fetchMetadata({
+            sourceUrl: input.item.source_url,
+            videoId: input.item.video_id,
+            title: input.item.title,
+        });
+        const result = {
+            video_file: null,
+            metadata_file: metadataFile,
+            final_file_size: null,
+            subtitle_files: {},
+            metadata,
+        };
+        const onProgress = (update) => {
+            currentStep = update.step;
+            manager?.updateItemProgress(jobId, input.item.video_id, update.step, update.progressPercent);
+        };
+        if (needsVideo(input.mode)) {
+            currentStep = "download_video";
+            manager?.updateItemProgress(jobId, input.item.video_id, currentStep, 0);
+            result.video_file = await deps.downloadVideo({
+                sourceUrl: input.item.source_url,
+                outputFile: videoFile,
+                videoQuality,
+                onProgress,
+            });
+            result.final_file_size = formatBytes((await deps.stat(result.video_file)).size);
+        }
+        if (needsSubtitles(input.mode)) {
+            currentStep = "download_subtitles";
+            manager?.updateItemProgress(jobId, input.item.video_id, currentStep, 0);
+            result.subtitle_files = await deps.downloadSubtitles({
+                videoId: input.item.video_id,
+                sourceUrl: input.item.source_url,
+                subtitlesDir,
+                formats: subtitleFormats,
+                languages: subtitleLanguages,
+                skipMissingLanguages: usingDefaultSubtitleLanguages,
+                onProgress,
+            });
+        }
+        currentStep = "write_metadata";
+        manager?.updateItemProgress(jobId, input.item.video_id, currentStep, 100);
+        await deps.writeMetadata(metadataFile, JSON.stringify(buildMetadataDocument({
+            item: input.item,
+            mode: input.mode,
+            videoQuality,
+            subtitleFormats,
+            metadata,
+            result,
+        }), null, 2));
+        manager?.completeItem(jobId, input.item.video_id, {
+            video_file: result.video_file,
+            metadata_file: result.metadata_file,
+            final_file_size: result.final_file_size,
+            subtitle_files: result.subtitle_files,
+        });
+        return result;
+    }
+    catch (error) {
+        const readableError = toErrorMessage(error);
+        if (manager && jobId) {
+            manager.failItem(jobId, input.item.video_id, readableError, currentStep);
+        }
+        throw new Error(readableError);
+    }
+}
+function resolveDeps(overrides) {
+    return {
+        hasYtDlp,
+        hasFfmpeg,
+        fetchMetadata: fetchMetadataWithYtDlp,
+        downloadVideo: downloadVideoWithYtDlp,
+        downloadSubtitles: downloadSubtitlesWithYtDlp,
+        mkdir: async (path, options) => {
+            await mkdir(path, options);
+        },
+        rm: async (path, options) => {
+            await rm(path, options);
+        },
+        stat,
+        writeMetadata: async (path, contents) => {
+            await writeFile(path, contents, "utf8");
+        },
+        ...overrides,
+    };
+}
+async function fetchMetadataWithYtDlp(input) {
+    const result = await runYtDlpJson([
+        "--dump-single-json",
+        "--skip-download",
+        "--no-playlist",
+        input.sourceUrl,
+    ]);
+    if (!result.ok) {
+        throw new Error(result.error);
+    }
+    return {
+        video_id: result.value.id ?? input.videoId,
+        source_url: result.value.webpage_url ?? input.sourceUrl,
+        title: result.value.title ?? input.title,
+        description: result.value.description,
+        channel_id: result.value.channel_id ?? result.value.uploader_id,
+        channel_title: result.value.channel ?? result.value.uploader,
+        published_at: normalizeUploadDate(result.value.upload_date),
+        duration: result.value.duration_string ?? formatDuration(result.value.duration),
+        thumbnail_url: result.value.thumbnail,
+    };
+}
+async function downloadVideoWithYtDlp(input) {
+    let lastProgress = 0;
+    const result = await runYtDlp([
+        "--no-playlist",
+        "--newline",
+        "--progress",
+        "--format",
+        resolveVideoFormat(input.videoQuality),
+        "--merge-output-format",
+        "mp4",
+        "--output",
+        input.outputFile.replace(/\.mp4$/u, ".%(ext)s"),
+        "--print",
+        "after_move:filepath",
+        input.sourceUrl,
+    ], 600_000, (line) => {
+        const parsed = parseYtDlpProgressLine(line);
+        if (parsed) {
+            lastProgress = Number(parsed.progress.replace(/%$/u, ""));
+            input.onProgress({ step: "download_video", progressPercent: lastProgress });
+            return;
+        }
+        if (line.includes("[Merger]")) {
+            input.onProgress({ step: "merge", progressPercent: Math.max(lastProgress, 99) });
+        }
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(result.stderr.slice(0, 500) || `yt-dlp exited with ${result.exitCode}`);
+    }
+    return resolveYtDlpOutputPath(input.outputFile, result.stdout);
+}
+async function downloadSubtitlesWithYtDlp(input) {
+    input.onProgress({ step: "download_subtitles", progressPercent: 0 });
+    return downloadSubtitlesForLanguages({
+        videoId: input.videoId,
+        sourceUrl: input.sourceUrl,
+        formats: input.formats,
+        languages: input.languages,
+        subtitlesDir: input.subtitlesDir,
+        skipMissingLanguages: input.skipMissingLanguages,
+        onProgress: (completed, total) => {
+            input.onProgress({
+                step: "download_subtitles",
+                progressPercent: total === 0 ? 100 : Math.round((completed / total) * 100),
+            });
+        },
+    });
+}
+function buildMetadataDocument(input) {
+    return {
+        video_id: input.metadata.video_id,
+        source_url: input.metadata.source_url,
+        title: input.metadata.title,
+        description: input.metadata.description ?? null,
+        channel_id: input.metadata.channel_id ?? null,
+        channel_title: input.metadata.channel_title ?? null,
+        published_at: input.metadata.published_at ?? null,
+        duration: input.metadata.duration ?? null,
+        thumbnail_url: input.metadata.thumbnail_url ?? null,
+        mode: input.mode,
+        video_quality: needsVideo(input.mode) ? input.videoQuality : null,
+        subtitle_formats: [...input.subtitleFormats],
+        output_dir: input.item.output_dir,
+        video_file: input.result.video_file,
+        metadata_file: input.result.metadata_file,
+        final_file_size: input.result.final_file_size,
+        subtitle_files: sortSubtitleFiles(input.result.subtitle_files),
+    };
+}
+export function resolveYtDlpOutputPath(expectedPath, stdout) {
+    const lines = stdout
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return lines.at(-1) ?? expectedPath;
+}
+function assertManagerInput(manager, jobId) {
+    if ((manager == null) !== (jobId == null)) {
+        throw new Error("jobManager and jobId must be provided together.");
+    }
+}
+function normalizeVideoQuality(videoQuality) {
+    return videoQuality === "max" ? "max" : "1080p";
+}
+function resolveVideoFormat(videoQuality) {
+    if (videoQuality === "max") {
+        return "bv*+ba/b";
+    }
+    return "bv*[height<=1080]+ba/b[height<=1080]/b";
+}
+function needsVideo(mode) {
+    return mode === "video" || mode === "both";
+}
+function needsSubtitles(mode) {
+    return mode === "subtitles" || mode === "both";
+}
+function normalizeUploadDate(uploadDate) {
+    if (!uploadDate || !/^\d{8}$/u.test(uploadDate)) {
+        return undefined;
+    }
+    return `${uploadDate.slice(0, 4)}-${uploadDate.slice(4, 6)}-${uploadDate.slice(6, 8)}`;
+}
+function formatDuration(durationSeconds) {
+    if (!Number.isFinite(durationSeconds) || durationSeconds == null || durationSeconds < 0) {
+        return undefined;
+    }
+    const wholeSeconds = Math.floor(durationSeconds);
+    const hours = Math.floor(wholeSeconds / 3600);
+    const minutes = Math.floor((wholeSeconds % 3600) / 60);
+    const seconds = wholeSeconds % 60;
+    if (hours > 0) {
+        return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+    }
+    return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+function sortSubtitleFiles(files) {
+    return Object.fromEntries(Object.entries(files)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([format, paths]) => [format, [...paths].sort()]));
+}
+function toErrorMessage(error) {
+    return toReadableSubtitleJobError(error);
+}

package/dist/download/jobManager.d.ts

@@ -0,0 +1,21 @@
+import type { CreateDownloadJobInput, DownloadJobItemSnapshot, DownloadJobSnapshot, DownloadStep } from "./types.js";
+interface DownloadJobManagerOptions {
+    now?: () => string;
+}
+export declare class DownloadJobManager {
+    private readonly jobs;
+    private readonly now;
+    constructor(options?: DownloadJobManagerOptions);
+    createJob(input: CreateDownloadJobInput): DownloadJobSnapshot;
+    pollJob(jobId: string): DownloadJobSnapshot;
+    startItem(jobId: string, videoId: string, step?: DownloadStep): DownloadJobSnapshot;
+    updateItemProgress(jobId: string, videoId: string, step: DownloadStep, progressPercent: number | null): DownloadJobSnapshot;
+    completeItem(jobId: string, videoId: string, outputs?: Pick<DownloadJobItemSnapshot, "video_file" | "metadata_file" | "final_file_size" | "subtitle_files">): DownloadJobSnapshot;
+    failItem(jobId: string, videoId: string, error: string, step?: DownloadStep): DownloadJobSnapshot;
+    private applyItemMutation;
+    private refreshJobStatus;
+    private getJob;
+    private getItem;
+    private toSnapshot;
+}
+export {};

package/dist/download/jobManager.js

@@ -0,0 +1,198 @@
+import { randomUUID } from "node:crypto";
+export class DownloadJobManager {
+    jobs = new Map();
+    now;
+    constructor(options = {}) {
+        this.now = options.now ?? (() => new Date().toISOString());
+    }
+    createJob(input) {
+        assertNonEmptyVideos(input);
+        const createdAt = this.now();
+        const jobId = randomUUID();
+        assertUniqueVideoIds(input);
+        const job = {
+            job_id: jobId,
+            status: "queued",
+            mode: input.mode,
+            video_quality: input.video_quality ?? null,
+            subtitle_formats: [...input.subtitle_formats],
+            created_at: createdAt,
+            started_at: null,
+            completed_at: null,
+            total: input.videos.length,
+            items: input.videos.map((video) => ({
+                video_id: video.video_id,
+                source_url: video.source_url,
+                title: video.title,
+                output_dir: video.output_dir,
+                status: "queued",
+                step: null,
+                progress_percent: null,
+                error: null,
+                started_at: null,
+                completed_at: null,
+                video_file: null,
+                metadata_file: null,
+                final_file_size: null,
+                subtitle_files: {},
+            })),
+        };
+        this.jobs.set(jobId, job);
+        return this.toSnapshot(job);
+    }
+    pollJob(jobId) {
+        return this.toSnapshot(this.getJob(jobId));
+    }
+    startItem(jobId, videoId, step = "metadata") {
+        const job = this.getJob(jobId);
+        const item = this.getItem(job, videoId);
+        this.applyItemMutation(job, item, {
+            status: "running",
+            step,
+            progress_percent: 0,
+            error: null,
+        });
+        return this.toSnapshot(job);
+    }
+    updateItemProgress(jobId, videoId, step, progressPercent) {
+        const job = this.getJob(jobId);
+        const item = this.getItem(job, videoId);
+        this.applyItemMutation(job, item, {
+            status: "running",
+            step,
+            progress_percent: progressPercent == null ? null : clampProgress(progressPercent),
+            error: null,
+        });
+        return this.toSnapshot(job);
+    }
+    completeItem(jobId, videoId, outputs) {
+        const job = this.getJob(jobId);
+        const item = this.getItem(job, videoId);
+        this.applyItemMutation(job, item, {
+            status: "completed",
+            step: "done",
+            progress_percent: 100,
+            error: null,
+            video_file: outputs?.video_file,
+            metadata_file: outputs?.metadata_file,
+            final_file_size: outputs?.final_file_size,
+            subtitle_files: outputs?.subtitle_files,
+        });
+        return this.toSnapshot(job);
+    }
+    failItem(jobId, videoId, error, step) {
+        const job = this.getJob(jobId);
+        const item = this.getItem(job, videoId);
+        this.applyItemMutation(job, item, {
+            status: "failed",
+            step: step ?? item.step,
+            error,
+        });
+        return this.toSnapshot(job);
+    }
+    applyItemMutation(job, item, mutation) {
+        const now = this.now();
+        const nextStatus = mutation.status;
+        const nextStep = mutation.step === undefined ? item.step : mutation.step;
+        const previousStatus = item.status;
+        item.status = nextStatus;
+        item.step = nextStep;
+        item.video_file = mutation.video_file === undefined ? item.video_file : mutation.video_file;
+        item.metadata_file = mutation.metadata_file === undefined ? item.metadata_file : mutation.metadata_file;
+        item.final_file_size =
+            mutation.final_file_size === undefined ? item.final_file_size : mutation.final_file_size;
+        item.subtitle_files = mutation.subtitle_files === undefined ? item.subtitle_files : cloneSubtitleFiles(mutation.subtitle_files);
+        if (nextStatus === "running") {
+            item.started_at = item.started_at ?? now;
+            job.started_at = job.started_at ?? now;
+            item.completed_at = null;
+            item.error = null;
+            item.progress_percent = resolveRunningProgress(item.progress_percent, mutation.progress_percent, previousStatus);
+        }
+        if (nextStatus === "completed" || nextStatus === "failed") {
+            item.started_at = item.started_at ?? now;
+            job.started_at = job.started_at ?? now;
+            item.completed_at = now;
+            item.error = mutation.error === undefined ? item.error : mutation.error;
+            item.progress_percent =
+                mutation.progress_percent === undefined ? item.progress_percent : clampProgressOrNull(mutation.progress_percent);
+        }
+        this.refreshJobStatus(job, now);
+    }
+    refreshJobStatus(job, now = this.now()) {
+        const statuses = job.items.map((item) => item.status);
+        if (statuses.every((status) => status === "completed")) {
+            job.status = "completed";
+            job.completed_at = job.completed_at ?? now;
+            return;
+        }
+        if (statuses.every((status) => status === "completed" || status === "failed")) {
+            job.status = "failed";
+            job.completed_at = job.completed_at ?? now;
+            return;
+        }
+        if (job.started_at !== null || statuses.some((status) => status !== "queued")) {
+            job.status = "running";
+            job.completed_at = null;
+            return;
+        }
+        job.status = "queued";
+        job.completed_at = null;
+    }
+    getJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job) {
+            throw new Error(`Unknown download job: ${jobId}`);
+        }
+        return job;
+    }
+    getItem(job, videoId) {
+        const item = job.items.find((entry) => entry.video_id === videoId);
+        if (!item) {
+            throw new Error(`Unknown download item: ${videoId}`);
+        }
+        return item;
+    }
+    toSnapshot(job) {
+        return {
+            ...job,
+            subtitle_formats: [...job.subtitle_formats],
+            items: job.items.map((item) => ({
+                ...item,
+                subtitle_files: cloneSubtitleFiles(item.subtitle_files),
+            })),
+        };
+    }
+}
+function clampProgress(value) {
+    return Math.max(0, Math.min(100, value));
+}
+function clampProgressOrNull(value) {
+    return value == null ? null : clampProgress(value);
+}
+function resolveRunningProgress(currentProgress, nextProgress, previousStatus) {
+    if (nextProgress !== undefined) {
+        return clampProgressOrNull(nextProgress);
+    }
+    if (previousStatus === "completed" || previousStatus === "failed") {
+        return 0;
+    }
+    return currentProgress ?? 0;
+}
+function assertUniqueVideoIds(input) {
+    const seen = new Set();
+    for (const video of input.videos) {
+        if (seen.has(video.video_id)) {
+            throw new Error(`Duplicate video_id in download job: ${video.video_id}`);
+        }
+        seen.add(video.video_id);
+    }
+}
+function assertNonEmptyVideos(input) {
+    if (input.videos.length === 0) {
+        throw new Error("Download job must include at least one video");
+    }
+}
+function cloneSubtitleFiles(files) {
+    return Object.fromEntries(Object.entries(files).map(([format, paths]) => [format, [...paths]]));
+}

package/dist/download/types.d.ts

@@ -0,0 +1,43 @@
+export type DownloadMode = "video" | "subtitles" | "both";
+export type DownloadItemStatus = "queued" | "running" | "completed" | "failed";
+export type DownloadStep = "metadata" | "download_video" | "download_subtitles" | "merge" | "write_metadata" | "done";
+export interface DownloadJobVideoInput {
+    video_id: string;
+    source_url: string;
+    title: string;
+    output_dir: string;
+}
+export interface CreateDownloadJobInput {
+    videos: DownloadJobVideoInput[];
+    mode: DownloadMode;
+    video_quality?: string;
+    subtitle_formats: string[];
+}
+export interface DownloadJobItemSnapshot {
+    video_id: string;
+    source_url: string;
+    title: string;
+    output_dir: string;
+    status: DownloadItemStatus;
+    step: DownloadStep | null;
+    progress_percent: number | null;
+    error: string | null;
+    started_at: string | null;
+    completed_at: string | null;
+    video_file: string | null;
+    metadata_file: string | null;
+    final_file_size: string | null;
+    subtitle_files: Record<string, string[]>;
+}
+export interface DownloadJobSnapshot {
+    job_id: string;
+    status: DownloadItemStatus;
+    mode: DownloadMode;
+    video_quality: string | null;
+    subtitle_formats: string[];
+    created_at: string;
+    started_at: string | null;
+    completed_at: string | null;
+    total: number;
+    items: DownloadJobItemSnapshot[];
+}

package/dist/download/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/ffmpegRuntime.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeComponentState } from "./manifest.js";
+export declare function checkFfmpegRuntime(): RuntimeComponentState & {
+    name: "ffmpeg";
+    message?: string;
+};
+export declare function installFfmpegRuntime(): Promise<RuntimeComponentState & {
+    name: "ffmpeg";
+    message?: string;
+}>;
+export declare function updateFfmpegRuntime(): Promise<RuntimeComponentState & {
+    name: "ffmpeg";
+    message?: string;
+}>;

package/dist/runtime/ffmpegRuntime.js

@@ -0,0 +1,51 @@
+import { execFileSync, execSync } from "node:child_process";
+import { getFfmpegPath, getRuntimeFfmpegPath } from "../utils/ffmpegPath.js";
+import { getFfmpegInstallHint } from "./systemDeps.js";
+function getFfmpegVersion(binPath) {
+    try {
+        const version = execFileSync(binPath, ["-version"], {
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 30_000,
+        }).toString("utf8");
+        const firstLine = version.split("\n")[0]?.trim();
+        return firstLine?.replace(/^ffmpeg version\s+/, "") ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function checkFfmpegRuntime() {
+    const resolved = getFfmpegPath();
+    const version = getFfmpegVersion(resolved);
+    if (!version) {
+        return {
+            name: "ffmpeg",
+            status: "missing",
+            version: null,
+            source: "system",
+            installed_at: null,
+            binary_path: null,
+            message: getFfmpegInstallHint(),
+        };
+    }
+    const source = process.env.FFMPEG_PATH
+        ? "env"
+        : resolved === getRuntimeFfmpegPath()
+            ? "runtime"
+            : "system";
+    return {
+        name: "ffmpeg",
+        status: "installed",
+        version,
+        source,
+        installed_at: null,
+        binary_path: resolved,
+    };
+}
+export async function installFfmpegRuntime() {
+    execSync(getFfmpegInstallHint(), { stdio: "inherit" });
+    return checkFfmpegRuntime();
+}
+export async function updateFfmpegRuntime() {
+    return installFfmpegRuntime();
+}

package/dist/runtime/installers.d.ts

@@ -0,0 +1,12 @@
+import { type RuntimeComponentName, type RuntimeComponentState } from "./manifest.js";
+export interface RuntimeComponentSummary extends RuntimeComponentState {
+    name: RuntimeComponentName;
+    message?: string;
+}
+export interface RuntimeSummary {
+    action: "check" | "install" | "update";
+    components: RuntimeComponentSummary[];
+}
+export declare function checkAll(): Promise<RuntimeSummary>;
+export declare function installAll(): Promise<RuntimeSummary>;
+export declare function updateAll(): Promise<RuntimeSummary>;

package/dist/runtime/installers.js

@@ -0,0 +1,45 @@
+import { checkPlaywrightRuntime, installPlaywrightRuntime, updatePlaywrightRuntime, } from "./playwrightRuntime.js";
+import { checkYtDlpRuntime, installYtDlpRuntime, updateYtDlpRuntime } from "./ytdlpRuntime.js";
+import { checkFfmpegRuntime, installFfmpegRuntime, updateFfmpegRuntime } from "./ffmpegRuntime.js";
+import { createEmptyRuntimeManifest, loadRuntimeManifest, saveRuntimeManifest, updateRuntimeComponent, } from "./manifest.js";
+import { PATHS } from "../utils/config.js";
+function persistComponents(components) {
+    let manifest = loadRuntimeManifest(PATHS.runtimeManifestJson) ?? createEmptyRuntimeManifest();
+    for (const component of components) {
+        manifest = updateRuntimeComponent(manifest, component.name, {
+            status: component.status,
+            version: component.version,
+            source: component.source,
+            installed_at: component.installed_at,
+            binary_path: component.binary_path,
+        });
+    }
+    saveRuntimeManifest(PATHS.runtimeManifestJson, manifest);
+}
+export async function checkAll() {
+    const components = [
+        await checkPlaywrightRuntime(),
+        checkYtDlpRuntime(),
+        checkFfmpegRuntime(),
+    ];
+    persistComponents(components);
+    return { action: "check", components };
+}
+export async function installAll() {
+    const components = [
+        await installPlaywrightRuntime(),
+        await installYtDlpRuntime(),
+        await installFfmpegRuntime(),
+    ];
+    persistComponents(components);
+    return { action: "install", components };
+}
+export async function updateAll() {
+    const components = [
+        await updatePlaywrightRuntime(),
+        await updateYtDlpRuntime(),
+        await updateFfmpegRuntime(),
+    ];
+    persistComponents(components);
+    return { action: "update", components };
+}

package/dist/runtime/manifest.d.ts

@@ -0,0 +1,18 @@
+export type RuntimeComponentName = "playwright" | "yt-dlp" | "ffmpeg";
+export type RuntimeComponentStatus = "missing" | "installed";
+export type RuntimeComponentSource = "runtime" | "system" | "env";
+export interface RuntimeComponentState {
+    status: RuntimeComponentStatus;
+    version: string | null;
+    source: RuntimeComponentSource;
+    installed_at: string | null;
+    binary_path: string | null;
+}
+export interface RuntimeManifest {
+    schema_version: 1;
+    components: Partial<Record<RuntimeComponentName, RuntimeComponentState>>;
+}
+export declare function createEmptyRuntimeManifest(): RuntimeManifest;
+export declare function loadRuntimeManifest(manifestPath?: string): RuntimeManifest;
+export declare function saveRuntimeManifest(manifestPath: string | undefined, manifest: RuntimeManifest): void;
+export declare function updateRuntimeComponent(manifest: RuntimeManifest, name: RuntimeComponentName, state: RuntimeComponentState): RuntimeManifest;