@mkterswingman/5mghost-yonder 0.0.2 → 0.0.4

package/dist/utils/ytdlp.js

@@ -1,8 +1,63 @@
 import { spawn } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { PATHS } from "./config.js";
 import { getYtDlpPath } from "./ytdlpPath.js";
-export function runYtDlp(args, timeoutMs = 45_000) {
+export function createYtDlpStderrLineSplitter(onLine) {
+    let buffer = "";
+    let pendingCarriageReturn = false;
+    const emit = () => {
+        if (buffer.length === 0) {
+            return;
+        }
+        try {
+            onLine(buffer);
+        }
+        catch {
+            // Why: progress observers are best-effort and must not break downloads.
+        }
+        buffer = "";
+    };
+    return {
+        push(chunk) {
+            const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            for (const ch of text) {
+                if (pendingCarriageReturn) {
+                    if (ch === "\n") {
+                        pendingCarriageReturn = false;
+                        emit();
+                        continue;
+                    }
+                    pendingCarriageReturn = false;
+                    emit();
+                }
+                if (ch === "\r") {
+                    pendingCarriageReturn = true;
+                    continue;
+                }
+                if (ch === "\n") {
+                    emit();
+                    continue;
+                }
+                buffer += ch;
+            }
+        },
+        flush() {
+            if (pendingCarriageReturn) {
+                pendingCarriageReturn = false;
+            }
+            emit();
+        },
+    };
+}
+export function hasYtDlp(runSpawnSync = spawnSync) {
+    const result = runSpawnSync(getYtDlpPath(), ["--version"], {
+        stdio: "ignore",
+        timeout: 30_000,
+    });
+    return result.status === 0 && result.error == null;
+}
+export function runYtDlp(args, timeoutMs = 45_000, onStderrLine) {
     return new Promise((resolve, reject) => {
         const start = Date.now();
         const finalArgs = ["--force-ipv4", "--no-warnings", ...args];
@@ -14,13 +69,23 @@ export function runYtDlp(args, timeoutMs = 45_000) {
         });
         const stdoutChunks = [];
         const stderrChunks = [];
+        const stderrSplitter = onStderrLine
+            ? createYtDlpStderrLineSplitter(onStderrLine)
+            : null;
         proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
-        proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        proc.stderr.on("data", (chunk) => {
+            stderrChunks.push(chunk);
+            stderrSplitter?.push(chunk);
+        });
+        function flushStderrLineBuffer() {
+            stderrSplitter?.flush();
+        }
         let settled = false;
         const timer = setTimeout(() => {
             if (!settled) {
                 settled = true;
                 proc.kill("SIGKILL");
+                flushStderrLineBuffer();
                 resolve({
                     exitCode: -1,
                     stdout: Buffer.concat(stdoutChunks).toString("utf8"),
@@ -33,6 +98,7 @@ export function runYtDlp(args, timeoutMs = 45_000) {
             clearTimeout(timer);
             if (!settled) {
                 settled = true;
+                flushStderrLineBuffer();
                 resolve({
                     exitCode: code ?? 1,
                     stdout: Buffer.concat(stdoutChunks).toString("utf8"),
@@ -50,3 +116,24 @@ export function runYtDlp(args, timeoutMs = 45_000) {
         });
     });
 }
+export async function runYtDlpJson(args, timeoutMs = 45_000) {
+    const result = await runYtDlp(args, timeoutMs);
+    if (result.exitCode !== 0) {
+        return {
+            ok: false,
+            error: result.stderr.slice(0, 500) || `yt-dlp exited with ${result.exitCode}`,
+        };
+    }
+    try {
+        return {
+            ok: true,
+            value: JSON.parse(result.stdout),
+        };
+    }
+    catch {
+        return {
+            ok: false,
+            error: "yt-dlp returned invalid JSON metadata.",
+        };
+    }
+}

package/dist/utils/ytdlpPath.d.ts

@@ -3,9 +3,16 @@
  *
  * Priority:
  *   1. YT_DLP_PATH env var (explicit override)
- *   2. Bundled binary at <pkg>/bin/yt-dlp (downloaded by postinstall)
+ *   2. Runtime-managed binary at ~/.yt-mcp/runtime/bin/yt-dlp
  *   3. "yt-dlp" — fall back to system PATH
  */
+export interface ResolveYtDlpPathOptions {
+    envPath?: string | null;
+    runtimePath?: string;
+    runtimeExists?: boolean;
+}
+export declare function getRuntimeYtDlpPath(runtimeBinDir?: string): string;
+export declare function resolveYtDlpPath(options?: ResolveYtDlpPathOptions): string;
 /**
  * Returns the absolute path to the yt-dlp binary, or the bare command name
  * "yt-dlp" if only available on system PATH.
@@ -13,7 +20,7 @@
 export declare function getYtDlpPath(): string;
 export interface YtDlpVersionInfo {
     version: string;
-    source: "bundled" | "system" | "env";
+    source: "runtime" | "system" | "env";
 }
 /**
  * Get the version string and source of the resolved yt-dlp binary.

package/dist/utils/ytdlpPath.js

@@ -3,35 +3,34 @@
  *
  * Priority:
  *   1. YT_DLP_PATH env var (explicit override)
- *   2. Bundled binary at <pkg>/bin/yt-dlp (downloaded by postinstall)
+ *   2. Runtime-managed binary at ~/.yt-mcp/runtime/bin/yt-dlp
  *   3. "yt-dlp" — fall back to system PATH
  */
 import { existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-// From dist/utils/ → package root is ../../
-const pkgRoot = join(__dirname, "..", "..");
-function bundledPath() {
+import { PATHS, buildRuntimeBinaryPath } from "./config.js";
+export function getRuntimeYtDlpPath(runtimeBinDir = PATHS.runtimeBinDir) {
     const name = process.platform === "win32" ? "yt-dlp.exe" : "yt-dlp";
-    return join(pkgRoot, "bin", name);
+    return buildRuntimeBinaryPath(runtimeBinDir, name);
+}
+export function resolveYtDlpPath(options = {}) {
+    const envPath = options.envPath ?? process.env.YT_DLP_PATH ?? null;
+    if (envPath) {
+        return envPath;
+    }
+    const runtimePath = options.runtimePath ?? getRuntimeYtDlpPath();
+    const runtimeExists = options.runtimeExists ?? existsSync(runtimePath);
+    if (runtimeExists) {
+        return runtimePath;
+    }
+    return "yt-dlp";
 }
 /**
  * Returns the absolute path to the yt-dlp binary, or the bare command name
  * "yt-dlp" if only available on system PATH.
  */
 export function getYtDlpPath() {
-    // 1. Explicit env override
-    const envPath = process.env.YT_DLP_PATH;
-    if (envPath && existsSync(envPath))
-        return envPath;
-    // 2. Bundled binary
-    const bundled = bundledPath();
-    if (existsSync(bundled))
-        return bundled;
-    // 3. System PATH
-    return "yt-dlp";
+    return resolveYtDlpPath();
 }
 /**
  * Get the version string and source of the resolved yt-dlp binary.
@@ -47,8 +46,8 @@ export function getYtDlpVersion(binPath) {
     if (process.env.YT_DLP_PATH && resolved === process.env.YT_DLP_PATH) {
         source = "env";
     }
-    else if (resolved === bundledPath()) {
-        source = "bundled";
+    else if (resolved === getRuntimeYtDlpPath()) {
+        source = "runtime";
     }
     else {
         source = "system";

package/dist/utils/ytdlpProgress.d.ts

@@ -0,0 +1,13 @@
+export interface ParsedYtDlpProgress {
+    progress: string;
+    downloaded_size?: string;
+    total_size?: string;
+    speed?: string;
+    eta?: string;
+}
+/**
+ * Parse the canonical yt-dlp download progress line used by this integration.
+ * Narrow contract: intentionally supports only representative `[download] ...`
+ * lines with percent, total size, speed, and ETA fields.
+ */
+export declare function parseYtDlpProgressLine(line: string): ParsedYtDlpProgress | null;

package/dist/utils/ytdlpProgress.js

@@ -0,0 +1,77 @@
+import { formatBytes, formatEta, formatPercent, formatSpeed } from "./formatters.js";
+const SIZE_UNITS = {
+    b: 1,
+    kb: 1000,
+    kib: 1024,
+    mb: 1000 ** 2,
+    mib: 1024 ** 2,
+    gb: 1000 ** 3,
+    gib: 1024 ** 3,
+    tb: 1000 ** 4,
+    tib: 1024 ** 4,
+};
+function parseSizeToBytes(text) {
+    const match = text.trim().match(/^(\d+(?:\.\d+)?)([kmgt]?i?b)$/i);
+    if (!match) {
+        return null;
+    }
+    const value = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    const multiplier = SIZE_UNITS[unit];
+    if (!Number.isFinite(value) || multiplier == null) {
+        return null;
+    }
+    return value * multiplier;
+}
+function parseEtaToSeconds(text) {
+    const trimmed = text.trim();
+    if (!trimmed || trimmed === "N/A") {
+        return null;
+    }
+    const hms = trimmed.match(/^(\d+):(\d{2}):(\d{2})$/);
+    if (hms) {
+        return Number(hms[1]) * 3600 + Number(hms[2]) * 60 + Number(hms[3]);
+    }
+    const ms = trimmed.match(/^(\d{1,2}):(\d{2})$/);
+    if (ms) {
+        return Number(ms[1]) * 60 + Number(ms[2]);
+    }
+    const unitMatch = trimmed.match(/^(\d+(?:\.\d+)?)([smhd])$/i);
+    if (unitMatch) {
+        const value = Number(unitMatch[1]);
+        const unit = unitMatch[2].toLowerCase();
+        const multiplier = unit === "s" ? 1 : unit === "m" ? 60 : unit === "h" ? 3600 : 86400;
+        return value * multiplier;
+    }
+    return null;
+}
+/**
+ * Parse the canonical yt-dlp download progress line used by this integration.
+ * Narrow contract: intentionally supports only representative `[download] ...`
+ * lines with percent, total size, speed, and ETA fields.
+ */
+export function parseYtDlpProgressLine(line) {
+    const match = line.match(/^\[download\]\s+(?<progress>\d+(?:\.\d+)?)% of (?<total>\S+)(?: at (?<speed>\S+?\/s))?(?: ETA (?<eta>\S+))?(?: \((?<details>.+)\))?$/);
+    if (!match?.groups?.progress) {
+        return null;
+    }
+    const progress = formatPercent(Number(match.groups.progress));
+    const totalBytes = match.groups.total ? parseSizeToBytes(match.groups.total) : null;
+    const speedBytes = match.groups.speed ? parseSizeToBytes(match.groups.speed.replace(/\/s$/i, "")) : null;
+    const etaSeconds = match.groups.eta ? parseEtaToSeconds(match.groups.eta) : null;
+    const parsed = { progress };
+    if (totalBytes != null) {
+        parsed.total_size = formatBytes(totalBytes);
+    }
+    if (speedBytes != null) {
+        parsed.speed = formatSpeed(speedBytes);
+    }
+    if (etaSeconds != null) {
+        parsed.eta = formatEta(etaSeconds);
+    }
+    if (totalBytes != null && Number.isFinite(Number(match.groups.progress))) {
+        const downloadedBytes = (totalBytes * Number(match.groups.progress)) / 100;
+        parsed.downloaded_size = formatBytes(downloadedBytes);
+    }
+    return parsed;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mkterswingman/5mghost-yonder",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Internal MCP client with local data tools and remote API proxy",
   "type": "module",
   "bin": {
@@ -11,9 +11,9 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test tests/*.test.mjs",
     "dev": "tsx src/cli/index.ts",
-    "start": "node dist/cli/index.js",
-    "postinstall": "node scripts/download-ytdlp.mjs"
+    "start": "node dist/cli/index.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.28.0",
@@ -35,6 +35,8 @@
   "files": [
     "dist/",
     "scripts/download-ytdlp.mjs",
+    "scripts/install.sh",
+    "scripts/install.ps1",
     "README.md"
   ],
   "devDependencies": {

package/scripts/download-ytdlp.mjs

@@ -39,7 +39,7 @@ const PLATFORM_MAP = {
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgRoot = join(__dirname, "..");
-const binDir = join(pkgRoot, "bin");
+const binDir = process.env.YT_MCP_BINARY_DIR || join(pkgRoot, "bin");
 
 function localName() {
   return process.platform === "win32" ? "yt-dlp.exe" : "yt-dlp";

package/scripts/install.ps1

@@ -0,0 +1,9 @@
+$ErrorActionPreference = "Stop"
+
+if (-not (Get-Command node -ErrorAction SilentlyContinue)) {
+  winget install OpenJS.NodeJS.LTS
+}
+
+npm install -g @mkterswingman/5mghost-yonder
+yt-mcp runtime install
+yt-mcp setup

package/scripts/install.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if ! command -v node >/dev/null 2>&1; then
+  if command -v brew >/dev/null 2>&1; then
+    brew install node
+  else
+    echo "Node.js is required. Install it first, then rerun this script." >&2
+    exit 1
+  fi
+fi
+
+npm install -g @mkterswingman/5mghost-yonder
+yt-mcp runtime install
+yt-mcp setup