@pagepocket/plugin-yt-dlp 0.8.5 → 0.9.0

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { default } from "./yt-dlp-plugin.js";
 export * from "./yt-dlp-plugin.js";
+export { setup } from "./setup.js";

package/dist/index.js

@@ -1,2 +1,3 @@
 export { default } from "./yt-dlp-plugin.js";
 export * from "./yt-dlp-plugin.js";
+export { setup } from "./setup.js";

package/dist/setup.d.ts

@@ -0,0 +1,6 @@
+export type BinaryPathJson = {
+    "yt-dlp": string;
+    ffmpeg: string;
+};
+export declare const resolveBinaryPathJsonFilePath: () => string;
+export declare const setup: () => Promise<void>;

package/dist/setup.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { helpers } from "ytdlp-nodejs";
+import { findExecutable } from "./utils/find-executable.js";
+const findNearestDirWithPackageJson = (startDir) => {
+    let dir = startDir;
+    for (;;) {
+        const pkgJsonPath = path.join(dir, "package.json");
+        if (fs.existsSync(pkgJsonPath)) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return startDir;
+        }
+        dir = parent;
+    }
+};
+const writeJsonAtomic = async (filePath, value) => {
+    const dir = path.dirname(filePath);
+    await fs.promises.mkdir(dir, { recursive: true });
+    const tmpPath = `${filePath}.tmp`;
+    await fs.promises.writeFile(tmpPath, `${JSON.stringify(value, undefined, 2)}\n`, "utf8");
+    await fs.promises.rename(tmpPath, filePath);
+};
+export const resolveBinaryPathJsonFilePath = () => {
+    const thisDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = findNearestDirWithPackageJson(thisDir);
+    return path.join(packageRoot, "binary-path.json");
+};
+export const setup = async () => {
+    console.info("Checking yt-dlp/ffmpeg on PATH...");
+    const ytdlpPath = await findExecutable("yt-dlp");
+    const ffmpegPath = await findExecutable("ffmpeg");
+    const outPath = resolveBinaryPathJsonFilePath();
+    if (ytdlpPath && ffmpegPath) {
+        console.info("Found yt-dlp/ffmpeg; writing binary-path.json");
+        const json = { "yt-dlp": ytdlpPath, ffmpeg: ffmpegPath };
+        await writeJsonAtomic(outPath, json);
+        return;
+    }
+    console.info("yt-dlp/ffmpeg not found; downloading via ytdlp-nodejs...");
+    const downloadedYtdlpPath = await helpers.downloadYtDlp();
+    const downloadedFfmpegPath = await helpers.downloadFFmpeg();
+    const resolvedFfmpegPath = downloadedFfmpegPath ?? helpers.findFFmpegBinary();
+    if (!resolvedFfmpegPath) {
+        throw new Error("Failed to download or locate ffmpeg via ytdlp-nodejs helpers.");
+    }
+    const json = { "yt-dlp": downloadedYtdlpPath, ffmpeg: resolvedFfmpegPath };
+    console.info("Download complete; writing binary-path.json");
+    await writeJsonAtomic(outPath, json);
+};

package/dist/utils/find-executable.d.ts

@@ -0,0 +1,7 @@
+type FindExecutableOptions = {
+    pathEnv?: string;
+    pathExtEnv?: string;
+    cwd?: string;
+};
+export declare const findExecutable: (command: string, options?: FindExecutableOptions) => Promise<string | undefined>;
+export {};

package/dist/utils/find-executable.js

@@ -0,0 +1,69 @@
+import nodeFs from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+const hasPathSeparator = (value) => value.includes("/") || value.includes("\\");
+const getWindowsPathExts = (pathExtEnv) => {
+    const raw = (pathExtEnv ?? process.env.PATHEXT ?? "").trim();
+    const defaults = [".COM", ".EXE", ".BAT", ".CMD"];
+    if (!raw) {
+        return defaults;
+    }
+    const extList = raw
+        .split(";")
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map((s) => (s.startsWith(".") ? s : `.${s}`));
+    return extList.length > 0 ? extList : defaults;
+};
+const isExecutableFile = async (absPath) => {
+    try {
+        const stat = await fs.stat(absPath);
+        if (!stat.isFile()) {
+            return false;
+        }
+        if (process.platform === "win32") {
+            return true;
+        }
+        await fs.access(absPath, nodeFs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const buildCandidateNames = (command, options) => {
+    if (process.platform !== "win32") {
+        return [command];
+    }
+    if (path.extname(command)) {
+        return [command];
+    }
+    const exts = getWindowsPathExts(options.pathExtEnv);
+    return exts.map((ext) => `${command}${ext.toLowerCase()}`);
+};
+export const findExecutable = async (command, options = {}) => {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const cwd = options.cwd ?? process.cwd();
+    if (hasPathSeparator(trimmed)) {
+        const abs = path.isAbsolute(trimmed) ? trimmed : path.resolve(cwd, trimmed);
+        return (await isExecutableFile(abs)) ? abs : undefined;
+    }
+    const pathEnv = options.pathEnv ?? process.env.PATH ?? "";
+    const dirs = pathEnv
+        .split(path.delimiter)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const candidateNames = buildCandidateNames(trimmed, options);
+    for (const dir of dirs) {
+        for (const name of candidateNames) {
+            const abs = path.join(dir, name);
+            if (await isExecutableFile(abs)) {
+                return abs;
+            }
+        }
+    }
+    return undefined;
+};

package/dist/utils/yt-dlp-job-manager.d.ts

@@ -10,7 +10,7 @@ export type YoutubeJob = {
 export declare const parseYoutubeEmbedSrc: (src: string) => {
     id: string;
     url: string;
-} | null;
+} | undefined;
 export declare class YtDlpJobManager {
     createSetupValue(now?: Date): SetupValue;
     buildVideoRelPath(setupValue: SetupValue, videoId: string): string;

package/dist/utils/yt-dlp-job-manager.js

@@ -4,21 +4,21 @@ export const parseYoutubeEmbedSrc = (src) => {
         const url = new URL(src, "https://www.youtube.com");
         const host = url.hostname;
         if (!host.endsWith("youtube.com") && !host.endsWith("youtube-nocookie.com")) {
-            return null;
+            return undefined;
         }
         const parts = url.pathname.split("/").filter(Boolean);
         const embedIndex = parts.indexOf("embed");
         if (embedIndex === -1) {
-            return null;
+            return undefined;
         }
         const id = parts[embedIndex + 1];
         if (!id) {
-            return null;
+            return undefined;
         }
         return { id, url: `https://www.youtube.com/watch?v=${id}` };
     }
     catch {
-        return null;
+        return undefined;
     }
 };
 const uniqueById = (jobs) => {

package/dist/utils/ytdlp.js

@@ -1,11 +1,50 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import pathMod from "node:path";
+import { YtDlp, helpers } from "ytdlp-nodejs";
+import { resolveBinaryPathJsonFilePath } from "../setup.js";
+const isBinaryPathJson = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const v = value;
+    return typeof v["yt-dlp"] === "string" && typeof v.ffmpeg === "string";
+};
+const readBinaryPathJson = async () => {
+    try {
+        const filePath = resolveBinaryPathJsonFilePath();
+        const text = await fs.readFile(filePath, "utf8");
+        const parsed = JSON.parse(text);
+        return isBinaryPathJson(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
 export const downloadVideosAsBytes = async (jobs) => {
-    const { YtDlp, helpers } = await import("ytdlp-nodejs");
-    const fs = await import("node:fs/promises");
-    const pathMod = await import("node:path");
-    const os = await import("node:os");
-    const ytdlp = new YtDlp();
-    await helpers.downloadYtDlp();
-    await helpers.downloadFFmpeg();
+    const binaryPathJson = await readBinaryPathJson();
+    if (!binaryPathJson) {
+        console.info("binary-path.json missing/invalid; downloading yt-dlp/ffmpeg via ytdlp-nodejs...");
+        await helpers.downloadYtDlp();
+        await helpers.downloadFFmpeg();
+        const resolvedYtdlpPath = helpers.findYtdlpBinary();
+        const resolvedFfmpegPath = helpers.findFFmpegBinary();
+        if (!resolvedYtdlpPath || !resolvedFfmpegPath) {
+            throw new Error("Failed to locate yt-dlp/ffmpeg after download.");
+        }
+        console.info("Binaries ready; starting yt-dlp downloads");
+        const ytdlp = new YtDlp({ binaryPath: resolvedYtdlpPath, ffmpegPath: resolvedFfmpegPath });
+        return await downloadWithYtdlp({ jobs, ytdlp, fs, pathMod, os });
+    }
+    const ytdlp = new YtDlp({
+        binaryPath: binaryPathJson["yt-dlp"],
+        ffmpegPath: binaryPathJson.ffmpeg
+    });
+    console.info("Using binary-path.json; starting yt-dlp downloads");
+    return await downloadWithYtdlp({ jobs, ytdlp, fs, pathMod, os });
+};
+const downloadWithYtdlp = async (input) => {
+    const { jobs, ytdlp, fs, pathMod, os } = input;
     const bytesById = new Map();
     await Promise.all(jobs.map(async (job) => {
         const tmpDir = await fs.mkdtemp(pathMod.join(os.tmpdir(), "pagepocket-ytdlp-"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagepocket/plugin-yt-dlp",
-  "version": "0.8.5",
+  "version": "0.9.0",
   "description": "PagePocket plugin: download YouTube embeds and replace with <video>",
   "type": "module",
   "main": "dist/index.js",
@@ -11,11 +11,12 @@
   "license": "ISC",
   "dependencies": {
     "ytdlp-nodejs": "^3.4.2",
-    "@pagepocket/shared": "0.8.5",
-    "@pagepocket/contracts": "0.8.5",
-    "@pagepocket/lib": "0.8.5"
+    "@pagepocket/lib": "0.9.0",
+    "@pagepocket/contracts": "0.9.0",
+    "@pagepocket/shared": "0.9.0"
   },
   "devDependencies": {
+    "@types/node": "^20.17.12",
     "typescript": "^5.4.5"
   },
   "scripts": {