@mkterswingman/5mghost-yonder 0.0.2 → 0.0.3

package/dist/tools/subtitles.js

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { z } from "zod";
 import { PATHS } from "../utils/config.js";
 import { runYtDlp } from "../utils/ytdlp.js";
@@ -7,6 +7,10 @@ import { hasSIDCookies, areCookiesExpired } from "../utils/cookies.js";
 import { tryHeadlessRefresh } from "../utils/cookieRefresh.js";
 import { resolveVideoInput, normalizeVideoInputs } from "../utils/videoInput.js";
 const AUTH_REQUIRED_MSG = "❌ 未认证。请先登录：\n• OAuth: npx @mkterswingman/5mghost-yonder setup\n• PAT: 设置环境变量 YT_MCP_TOKEN 或在 https://mkterswingman.com/pat/login 生成 token";
+const COOKIE_SETUP_COMMAND = "yt-mcp setup-cookies";
+const COOKIE_MISSING_MESSAGE = `No valid YouTube cookies found.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
+const COOKIE_EXPIRED_MESSAGE = `YouTube cookies have expired and auto-refresh failed.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
+const COOKIE_JOB_MESSAGE = `YouTube cookies are missing or expired.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
 function toolOk(payload) {
     return {
         structuredContent: payload,
@@ -32,6 +36,44 @@ function sleep(ms) {
 function randomSleep(min, max) {
     return sleep(Math.random() * (max - min) + min);
 }
+async function tryRefreshSubtitleCookies() {
+    try {
+        return await tryHeadlessRefresh();
+    }
+    catch {
+        return false;
+    }
+}
+function isCookieFailureText(error) {
+    if (!error) {
+        return false;
+    }
+    const normalized = error.toLowerCase();
+    return (normalized.includes("cookies_expired") ||
+        normalized.includes("cookie") ||
+        normalized.includes("sign in") ||
+        normalized.includes("login") ||
+        normalized.includes("not a bot"));
+}
+export function toReadableSubtitleJobError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return isCookieFailureText(message) ? COOKIE_JOB_MESSAGE : message;
+}
+async function ensureSubtitleCookiesReady() {
+    if (hasSIDCookies(PATHS.cookiesTxt) && !areCookiesExpired(PATHS.cookiesTxt)) {
+        return { ok: true };
+    }
+    const refreshed = await tryRefreshSubtitleCookies();
+    if (refreshed && hasSIDCookies(PATHS.cookiesTxt) && !areCookiesExpired(PATHS.cookiesTxt)) {
+        return { ok: true };
+    }
+    return {
+        ok: false,
+        code: "COOKIES_MISSING",
+        toolMessage: COOKIE_MISSING_MESSAGE,
+        jobMessage: COOKIE_JOB_MESSAGE,
+    };
+}
 /**
  * Decode common HTML entities found in YouTube auto-captions.
  */
@@ -88,7 +130,7 @@ function csvEscapeField(value) {
  * 3. For manual subtitles: passes through cleanly with no data loss
  * 4. Outputs: start_time, end_time, text
  */
-function vttToCsv(vtt) {
+export function vttToCsv(vtt) {
     const lines = vtt.split("\n");
     const isAutoCaption = /<\d{2}:\d{2}:\d{2}\.\d{3}><c>/.test(vtt);
     const rawCues = [];
@@ -180,9 +222,13 @@ function todayDateStr() {
     const dd = String(d.getDate()).padStart(2, "0");
     return `${yyyy}-${mm}-${dd}`;
 }
-async function downloadSubtitle(videoId, lang, format) {
-    mkdirSync(PATHS.subtitlesDir, { recursive: true });
-    const outTemplate = join(PATHS.subtitlesDir, `${todayDateStr()}_${videoId}_${lang}`);
+async function downloadSubtitle(videoId, lang, format, options = {}) {
+    const outputDir = options.outputDir ?? PATHS.subtitlesDir;
+    mkdirSync(outputDir, { recursive: true });
+    if (options.targetFile) {
+        mkdirSync(dirname(options.targetFile), { recursive: true });
+    }
+    const outTemplate = join(outputDir, options.outputStem ?? `${todayDateStr()}_${videoId}_${lang}`);
     // CSV is not a yt-dlp native format — download as VTT then convert
     const dlFormat = format === "csv" ? "vtt" : format;
     const result = await runYtDlp([
@@ -196,7 +242,7 @@ async function downloadSubtitle(videoId, lang, format) {
         dlFormat,
         "--output",
         outTemplate,
-        `https://www.youtube.com/watch?v=${videoId}`,
+        options.sourceUrl ?? `https://www.youtube.com/watch?v=${videoId}`,
     ]);
     if (result.exitCode !== 0 &&
         (result.stderr.includes("Sign in") ||
@@ -224,10 +270,10 @@ async function downloadSubtitle(videoId, lang, format) {
     }
     if (!foundFile) {
         // Try auto-generated subtitles which may have slightly different naming
-        const dir = PATHS.subtitlesDir;
+        const dir = outputDir;
         try {
             const files = readdirSync(dir);
-            const prefix = `${todayDateStr()}_${videoId}_${lang}`;
+            const prefix = options.outputStem ?? `${todayDateStr()}_${videoId}_${lang}`;
             const match = files.find((f) => f.startsWith(prefix));
             if (match) {
                 foundFile = join(dir, match);
@@ -245,11 +291,24 @@ async function downloadSubtitle(videoId, lang, format) {
     }
     // If CSV format requested, convert VTT to CSV (timestamp, text)
     if (format === "csv") {
+        const vttPath = foundFile;
         const vttContent = readFileSync(foundFile, "utf8");
         const csvContent = vttToCsv(vttContent);
         const csvPath = foundFile.replace(/\.vtt$/, ".csv");
         writeFileSync(csvPath, csvContent, "utf8");
         foundFile = csvPath;
+        if (vttPath !== csvPath) {
+            try {
+                unlinkSync(vttPath);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    if (options.targetFile && foundFile !== options.targetFile) {
+        renameSync(foundFile, options.targetFile);
+        foundFile = options.targetFile;
     }
     const stat = statSync(foundFile);
     if (stat.size <= 100 * 1024) {
@@ -258,6 +317,63 @@ async function downloadSubtitle(videoId, lang, format) {
     }
     return { ok: true, filePath: foundFile };
 }
+export async function downloadSubtitlesForLanguages(input) {
+    const cookieCheck = await ensureSubtitleCookiesReady();
+    if (!cookieCheck.ok) {
+        throw new Error(cookieCheck.jobMessage);
+    }
+    const filesByFormat = {};
+    const total = input.formats.length * input.languages.length;
+    let completed = 0;
+    for (const format of input.formats) {
+        filesByFormat[format] = [];
+        for (const lang of input.languages) {
+            const targetFile = join(input.subtitlesDir, `${lang}.${format}`);
+            let result = await downloadSubtitle(input.videoId, lang, format, {
+                sourceUrl: input.sourceUrl,
+                outputDir: input.subtitlesDir,
+                outputStem: `${lang}`,
+                targetFile,
+            });
+            if (result.cookiesExpired) {
+                const refreshed = await tryRefreshSubtitleCookies();
+                if (refreshed) {
+                    result = await downloadSubtitle(input.videoId, lang, format, {
+                        sourceUrl: input.sourceUrl,
+                        outputDir: input.subtitlesDir,
+                        outputStem: `${lang}`,
+                        targetFile,
+                    });
+                }
+            }
+            if (!result.ok || !result.filePath) {
+                if (isCookieFailureText(result.error)) {
+                    throw new Error(COOKIE_JOB_MESSAGE);
+                }
+                if (input.skipMissingLanguages && isUnavailableSubtitleError(result.error)) {
+                    completed += 1;
+                    input.onProgress?.(completed, total);
+                    continue;
+                }
+                throw new Error(result.error ?? `Failed to download ${format} subtitle for ${lang}`);
+            }
+            filesByFormat[format].push(result.filePath);
+            completed += 1;
+            input.onProgress?.(completed, total);
+        }
+    }
+    return filesByFormat;
+}
+function isUnavailableSubtitleError(error) {
+    if (!error) {
+        return false;
+    }
+    const normalized = error.toLowerCase();
+    return (normalized.includes("no subtitle file found") ||
+        normalized.includes("no subtitles") ||
+        normalized.includes("subtitle is not available") ||
+        normalized.includes("requested subtitles are not available"));
+}
 export function registerSubtitleTools(server, config, tokenManager) {
     /**
      * Auth guard — every tool call must pass authentication.
@@ -285,16 +401,9 @@ export function registerSubtitleTools(server, config, tokenManager) {
         const videoId = resolveVideoInput(video);
         if (!videoId)
             return toolErr("INVALID_INPUT", `无法解析视频 ID: ${video}`);
-        // Cookie pre-check: missing or expired → try headless refresh
-        if (!hasSIDCookies(PATHS.cookiesTxt) || areCookiesExpired(PATHS.cookiesTxt)) {
-            let refreshed = false;
-            try {
-                refreshed = await tryHeadlessRefresh();
-            }
-            catch { /* */ }
-            if (!refreshed || !hasSIDCookies(PATHS.cookiesTxt)) {
-                return toolErr("COOKIES_MISSING", "No valid YouTube cookies found.\nPlease run in your terminal: yt-mcp setup-cookies");
-            }
+        const cookieCheck = await ensureSubtitleCookiesReady();
+        if (!cookieCheck.ok) {
+            return toolErr(cookieCheck.code, cookieCheck.toolMessage);
         }
         const usingDefaults = !languages;
         const langs = languages ?? config.default_languages;
@@ -307,14 +416,7 @@ export function registerSubtitleTools(server, config, tokenManager) {
             const lang = langs[i];
             const dl = await downloadSubtitle(videoId, lang, fmt);
             if (dl.cookiesExpired) {
-                // Try headless auto-refresh
-                let refreshed = false;
-                try {
-                    refreshed = await tryHeadlessRefresh();
-                }
-                catch {
-                    // Playwright not available or browser failed — fall through
-                }
+                const refreshed = await tryRefreshSubtitleCookies();
                 if (refreshed) {
                     // Retry the download with fresh cookies
                     const retry = await downloadSubtitle(videoId, lang, fmt);
@@ -329,8 +431,7 @@ export function registerSubtitleTools(server, config, tokenManager) {
                     }
                     // Retry also failed with expired cookies — give up
                 }
-                return toolErr("COOKIES_EXPIRED", "YouTube cookies have expired and auto-refresh failed.\n" +
-                    "Please run in your terminal: yt-mcp setup-cookies");
+                return toolErr("COOKIES_EXPIRED", COOKIE_EXPIRED_MESSAGE);
             }
             if (!dl.ok) {
                 // When using default languages, silently skip unavailable ones
@@ -383,16 +484,9 @@ export function registerSubtitleTools(server, config, tokenManager) {
         }
         const langs = languages ?? config.default_languages;
         const fmt = format ?? "vtt";
-        // Cookie pre-check: missing or expired → try headless refresh
-        if (!hasSIDCookies(PATHS.cookiesTxt) || areCookiesExpired(PATHS.cookiesTxt)) {
-            let refreshed = false;
-            try {
-                refreshed = await tryHeadlessRefresh();
-            }
-            catch { /* */ }
-            if (!refreshed || !hasSIDCookies(PATHS.cookiesTxt)) {
-                return toolErr("COOKIES_MISSING", "No valid YouTube cookies found.\nPlease run in your terminal: yt-mcp setup-cookies");
-            }
+        const cookieCheck = await ensureSubtitleCookiesReady();
+        if (!cookieCheck.ok) {
+            return toolErr(cookieCheck.code, cookieCheck.toolMessage);
         }
         const results = [];
         let succeeded = 0;
@@ -422,12 +516,7 @@ export function registerSubtitleTools(server, config, tokenManager) {
                 }
             }
             if (cookiesExpired) {
-                // Try headless auto-refresh
-                let refreshed = false;
-                try {
-                    refreshed = await tryHeadlessRefresh();
-                }
-                catch { /* fall through */ }
+                const refreshed = await tryRefreshSubtitleCookies();
                 if (refreshed) {
                     // Retry this video's subtitles
                     let retrySuccess = false;
@@ -443,8 +532,7 @@ export function registerSubtitleTools(server, config, tokenManager) {
                     }
                 }
                 if (cookiesExpired) {
-                    return toolErr("COOKIES_EXPIRED", "YouTube cookies have expired and auto-refresh failed.\n" +
-                        "Please run in your terminal: yt-mcp setup-cookies");
+                    return toolErr("COOKIES_EXPIRED", COOKIE_EXPIRED_MESSAGE);
                 }
             }
             if (langFound.length > 0) {

package/dist/utils/config.d.ts

@@ -1,3 +1,26 @@
+export declare function getConfigDir(homeDir?: string): string;
+export declare function getSharedAuthDir(homeDir?: string): string;
+export declare const MEDIA_ROOT_DIR: string;
+export declare function buildRuntimeBinaryPath(runtimeBinDir: string, binaryName: string): string;
+export declare function buildPaths(homeDir?: string): {
+    configDir: string;
+    authJson: string;
+    cookiesTxt: string;
+    browserProfile: string;
+    launcherJs: string;
+    npmCacheDir: string;
+    subtitlesDir: string;
+    configJson: string;
+    runtimeRootDir: string;
+    runtimeBinDir: string;
+    runtimeManifestJson: string;
+    sharedAuthDir: string;
+    sharedAuthJson: string;
+};
+export declare function buildSharedPaths(homeDir?: string): {
+    sharedAuthDir: string;
+    sharedAuthJson: string;
+};
 export declare const PATHS: {
     configDir: string;
     authJson: string;
@@ -7,6 +30,11 @@ export declare const PATHS: {
     npmCacheDir: string;
     subtitlesDir: string;
     configJson: string;
+    runtimeRootDir: string;
+    runtimeBinDir: string;
+    runtimeManifestJson: string;
+    sharedAuthDir: string;
+    sharedAuthJson: string;
 };
 export interface YtMcpConfig {
     /** Auth gateway root URL — for OAuth, PAT, introspection (e.g., https://mkterswingman.com) */

package/dist/utils/config.js

@@ -1,17 +1,46 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-const CONFIG_DIR = join(homedir(), ".yt-mcp");
-const SUBTITLES_DIR = join(homedir(), "Downloads", "yt-mcp");
+export function getConfigDir(homeDir = homedir()) {
+    return join(homeDir, ".yt-mcp");
+}
+export function getSharedAuthDir(homeDir = homedir()) {
+    return join(homeDir, ".mkterswingman");
+}
+export const MEDIA_ROOT_DIR = join(homedir(), "Downloads", "yt-mcp");
+export function buildRuntimeBinaryPath(runtimeBinDir, binaryName) {
+    return join(runtimeBinDir, binaryName);
+}
+export function buildPaths(homeDir = homedir()) {
+    const configDir = getConfigDir(homeDir);
+    const runtimeRootDir = join(configDir, "runtime");
+    const runtimeBinDir = join(runtimeRootDir, "bin");
+    const sharedAuthDir = getSharedAuthDir(homeDir);
+    return {
+        configDir,
+        authJson: join(configDir, "auth.json"),
+        cookiesTxt: join(configDir, "cookies.txt"),
+        browserProfile: join(configDir, "browser-profile"),
+        launcherJs: join(configDir, "launcher.mjs"),
+        npmCacheDir: join(configDir, "npm-cache"),
+        subtitlesDir: MEDIA_ROOT_DIR,
+        configJson: join(configDir, "config.json"),
+        runtimeRootDir,
+        runtimeBinDir,
+        runtimeManifestJson: join(runtimeRootDir, "runtime.json"),
+        sharedAuthDir,
+        sharedAuthJson: join(sharedAuthDir, "auth.json"),
+    };
+}
+export function buildSharedPaths(homeDir = homedir()) {
+    const sharedAuthDir = getSharedAuthDir(homeDir);
+    return {
+        sharedAuthDir,
+        sharedAuthJson: join(sharedAuthDir, "auth.json"),
+    };
+}
 export const PATHS = {
-    configDir: CONFIG_DIR,
-    authJson: join(CONFIG_DIR, "auth.json"),
-    cookiesTxt: join(CONFIG_DIR, "cookies.txt"),
-    browserProfile: join(CONFIG_DIR, "browser-profile"),
-    launcherJs: join(CONFIG_DIR, "launcher.mjs"),
-    npmCacheDir: join(CONFIG_DIR, "npm-cache"),
-    subtitlesDir: SUBTITLES_DIR,
-    configJson: join(CONFIG_DIR, "config.json"),
+    ...buildPaths(),
 };
 const DEFAULTS = {
     auth_url: "https://mkterswingman.com",
@@ -23,7 +52,7 @@ const DEFAULTS = {
     batch_max_size: 10,
 };
 export function ensureConfigDir() {
-    mkdirSync(CONFIG_DIR, { recursive: true });
+    mkdirSync(PATHS.configDir, { recursive: true });
 }
 export function loadConfig() {
     ensureConfigDir();

package/dist/utils/ffmpeg.d.ts

@@ -0,0 +1,5 @@
+import { spawnSync } from "node:child_process";
+type SpawnSyncFn = typeof spawnSync;
+export declare function hasFfmpeg(runSpawnSync?: SpawnSyncFn): boolean;
+export declare function isRuntimeMissingMessage(binary: "ffmpeg" | "yt-dlp"): string;
+export {};

package/dist/utils/ffmpeg.js

@@ -0,0 +1,16 @@
+import { spawnSync } from "node:child_process";
+export function hasFfmpeg(runSpawnSync = spawnSync) {
+    return hasBinary("ffmpeg", runSpawnSync);
+}
+function hasBinary(binary, runSpawnSync) {
+    const result = runSpawnSync(binary, ["-version"], {
+        stdio: "ignore",
+        timeout: 30_000,
+    });
+    // Why: runtime probing should fail closed when the binary is absent,
+    // exits non-zero, or times out instead of hanging the caller.
+    return result.status === 0 && result.error == null;
+}
+export function isRuntimeMissingMessage(binary) {
+    return `${binary} is required for media download.`;
+}

package/dist/utils/ffmpegPath.d.ts

@@ -0,0 +1,8 @@
+export interface ResolveFfmpegPathOptions {
+    envPath?: string | null;
+    runtimePath?: string;
+    runtimeExists?: boolean;
+}
+export declare function getRuntimeFfmpegPath(runtimeBinDir?: string): string;
+export declare function resolveFfmpegPath(options?: ResolveFfmpegPathOptions): string;
+export declare function getFfmpegPath(): string;

package/dist/utils/ffmpegPath.js

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs";
+import { PATHS, buildRuntimeBinaryPath } from "./config.js";
+export function getRuntimeFfmpegPath(runtimeBinDir = PATHS.runtimeBinDir) {
+    const name = process.platform === "win32" ? "ffmpeg.exe" : "ffmpeg";
+    return buildRuntimeBinaryPath(runtimeBinDir, name);
+}
+export function resolveFfmpegPath(options = {}) {
+    const envPath = options.envPath ?? process.env.FFMPEG_PATH ?? null;
+    if (envPath) {
+        return envPath;
+    }
+    const runtimePath = options.runtimePath ?? getRuntimeFfmpegPath();
+    const runtimeExists = options.runtimeExists ?? existsSync(runtimePath);
+    if (runtimeExists) {
+        return runtimePath;
+    }
+    return "ffmpeg";
+}
+export function getFfmpegPath() {
+    return resolveFfmpegPath();
+}

package/dist/utils/formatters.d.ts

@@ -0,0 +1,4 @@
+export declare function formatPercent(value: number): string;
+export declare function formatBytes(bytes: number): string;
+export declare function formatSpeed(bytesPerSecond: number): string;
+export declare function formatEta(seconds: number): string;

package/dist/utils/formatters.js

@@ -0,0 +1,42 @@
+const UNITS = ["B", "KB", "MB", "GB", "TB"];
+function formatScaled(value) {
+    if (!Number.isFinite(value) || value < 0) {
+        return "0 B";
+    }
+    let scaled = value;
+    let unitIndex = 0;
+    while (scaled >= 1024 && unitIndex < UNITS.length - 1) {
+        scaled /= 1024;
+        unitIndex++;
+    }
+    const floored = Math.floor(scaled * 10) / 10;
+    return `${Number.isInteger(floored) ? floored.toFixed(0) : floored} ${UNITS[unitIndex]}`;
+}
+export function formatPercent(value) {
+    return `${Math.max(0, Math.min(100, Math.round(value)))}%`;
+}
+export function formatBytes(bytes) {
+    return formatScaled(bytes);
+}
+export function formatSpeed(bytesPerSecond) {
+    return `${formatBytes(bytesPerSecond)}/s`;
+}
+export function formatEta(seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return "0s";
+    }
+    let remaining = Math.floor(seconds);
+    const hours = Math.floor(remaining / 3600);
+    remaining -= hours * 3600;
+    const minutes = Math.floor(remaining / 60);
+    remaining -= minutes * 60;
+    const parts = [];
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes > 0 || hours > 0) {
+        parts.push(`${minutes}m`);
+    }
+    parts.push(`${remaining}s`);
+    return parts.join(" ");
+}

package/dist/utils/mediaPaths.d.ts

@@ -0,0 +1,7 @@
+export interface MediaOutputPaths {
+    outputDir: string;
+    videoFile: string;
+    metadataFile: string;
+    subtitlesDir: string;
+}
+export declare function buildMediaOutputPaths(rootDir: string, dateStr: string, videoId: string): MediaOutputPaths;

package/dist/utils/mediaPaths.js

@@ -0,0 +1,10 @@
+import { join } from "node:path";
+export function buildMediaOutputPaths(rootDir, dateStr, videoId) {
+    const outputDir = join(rootDir, `${dateStr}_${videoId}`);
+    return {
+        outputDir,
+        videoFile: join(outputDir, "video.mp4"),
+        metadataFile: join(outputDir, "metadata.json"),
+        subtitlesDir: join(outputDir, "subtitles"),
+    };
+}

package/dist/utils/openClaw.d.ts

@@ -0,0 +1,17 @@
+import type { LauncherCommand } from "./launcher.js";
+export interface OpenClawServerConfig {
+    transport: "stdio";
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export declare function getOpenClawConfigPath(homeDir?: string): string;
+export declare function buildOpenClawServerConfig(launcherCommand: LauncherCommand): OpenClawServerConfig;
+export declare function upsertOpenClawConfigText(currentText: string | null, serverName: string, launcherCommand: LauncherCommand): string;
+export declare function removeOpenClawConfigEntryText(currentText: string | null, serverName: string): {
+    changed: boolean;
+    nextText: string | null;
+};
+export declare function isOpenClawInstallLikelyInstalled(detectBinary: (name: string) => boolean, configPath?: string): boolean;
+export declare function writeOpenClawConfig(serverName: string, launcherCommand: LauncherCommand, configPath?: string): "created" | "updated";
+export declare function removeOpenClawConfig(serverName: string, configPath?: string): "removed" | "missing";

package/dist/utils/openClaw.js

@@ -0,0 +1,79 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export function getOpenClawConfigPath(homeDir = homedir()) {
+    return join(homeDir, ".openclaw", "workspace", "config", "mcporter.json");
+}
+export function buildOpenClawServerConfig(launcherCommand) {
+    return {
+        transport: "stdio",
+        command: launcherCommand.command,
+        args: [...launcherCommand.args],
+    };
+}
+function parseOpenClawConfig(raw) {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+        return parsed;
+    }
+    throw new Error("OpenClaw mcporter.json must be a JSON object");
+}
+export function upsertOpenClawConfigText(currentText, serverName, launcherCommand) {
+    const config = currentText ? parseOpenClawConfig(currentText) : {};
+    const servers = config.servers && typeof config.servers === "object" ? { ...config.servers } : {};
+    servers[serverName] = buildOpenClawServerConfig(launcherCommand);
+    const nextConfig = {
+        ...config,
+        servers,
+    };
+    return JSON.stringify(nextConfig, null, 2);
+}
+export function removeOpenClawConfigEntryText(currentText, serverName) {
+    if (!currentText) {
+        return { changed: false, nextText: null };
+    }
+    const config = parseOpenClawConfig(currentText);
+    if (!config.servers || typeof config.servers !== "object" || !(serverName in config.servers)) {
+        return { changed: false, nextText: currentText };
+    }
+    const servers = { ...config.servers };
+    delete servers[serverName];
+    const nextConfig = { ...config };
+    if (Object.keys(servers).length === 0) {
+        delete nextConfig.servers;
+    }
+    else {
+        nextConfig.servers = servers;
+    }
+    return {
+        changed: true,
+        nextText: JSON.stringify(nextConfig, null, 2),
+    };
+}
+export function isOpenClawInstallLikelyInstalled(detectBinary, configPath = getOpenClawConfigPath()) {
+    if (detectBinary("mcporter") || detectBinary("openclaw")) {
+        return true;
+    }
+    return existsSync(configPath) || existsSync(dirname(configPath));
+}
+export function writeOpenClawConfig(serverName, launcherCommand, configPath = getOpenClawConfigPath()) {
+    const existingText = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
+    const created = existingText === null;
+    const nextText = upsertOpenClawConfigText(existingText, serverName, launcherCommand);
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, `${nextText}\n`, "utf8");
+    return created ? "created" : "updated";
+}
+export function removeOpenClawConfig(serverName, configPath = getOpenClawConfigPath()) {
+    const existingText = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
+    const result = removeOpenClawConfigEntryText(existingText, serverName);
+    if (!result.changed) {
+        return "missing";
+    }
+    if (!result.nextText) {
+        rmSync(configPath, { force: true });
+        return "removed";
+    }
+    writeFileSync(configPath, `${result.nextText}\n`, "utf8");
+    return "removed";
+}

package/dist/utils/videoInput.js

@@ -13,6 +13,9 @@ function extractFromUrl(raw) {
     }
     const host = url.hostname.toLowerCase();
     const normalizedHost = host.startsWith("www.") ? host.slice(4) : host;
+    if (url.searchParams.has("list")) {
+        return null;
+    }
     if (normalizedHost === "youtu.be") {
         const id = url.pathname.split("/").filter(Boolean)[0] ?? "";
         return toValidVideoId(id);

package/dist/utils/videoMetadata.d.ts

@@ -0,0 +1,11 @@
+export interface PreflightVideoMetadata {
+    video_id: string;
+    source_url: string;
+    title: string;
+    channel_title?: string;
+    channel_id?: string;
+    description?: string;
+    duration?: string;
+    published_at?: string;
+    thumbnail_url?: string;
+}

package/dist/utils/videoMetadata.js

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

package/dist/utils/ytdlp.d.ts

@@ -1,7 +1,23 @@
+import { spawnSync } from "node:child_process";
 export interface YtDlpResult {
     exitCode: number;
     stdout: string;
     stderr: string;
     durationMs: number;
 }
-export declare function runYtDlp(args: string[], timeoutMs?: number): Promise<YtDlpResult>;
+export interface YtDlpStderrLineSplitter {
+    push(chunk: Buffer | string): void;
+    flush(): void;
+}
+type SpawnSyncFn = typeof spawnSync;
+export declare function createYtDlpStderrLineSplitter(onLine: (line: string) => void): YtDlpStderrLineSplitter;
+export declare function hasYtDlp(runSpawnSync?: SpawnSyncFn): boolean;
+export declare function runYtDlp(args: string[], timeoutMs?: number, onStderrLine?: (line: string) => void): Promise<YtDlpResult>;
+export declare function runYtDlpJson<T>(args: string[], timeoutMs?: number): Promise<{
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+}>;
+export {};