ytdl-rmcp 0.7.1

package/README.md

@@ -0,0 +1,53 @@
+# ytdl-rmcp
+
+Node launcher for the `ytdl-rmcp` Rust MCP server and CLI binary.
+
+```bash
+npx -y ytdl-rmcp
+```
+
+Run the guided setup:
+
+```bash
+npx -y ytdl-rmcp setup
+```
+
+Install globally when you want the command on `PATH`:
+
+```bash
+npm i -g ytdl-rmcp
+ytdl-rmcp --version
+ytdl-rmcp setup
+```
+
+The package downloads the matching GitHub Release binary during `postinstall`.
+The npm package version and the `ytdl-rmcp` release tag are expected to match.
+Release automation publishes this package from the repository `v*` tag workflow;
+the GitHub repository must have an `NPM_TOKEN` secret with publish access.
+
+## MCP stdio
+
+Run without subcommands, `ytdl-rmcp` serves MCP over stdio. MCP clients can launch
+it with:
+
+```json
+{
+  "command": "npx",
+  "args": ["-y", "ytdl-rmcp"],
+  "env": {
+    "YTDLP_REMOTE": "tootie",
+    "YTDLP_REMOTE_PATH": "/media/music"
+  }
+}
+```
+
+## Overrides
+
+```bash
+YTDL_RMCP_BINARY_VERSION=v0.7.0 npm i -g ytdl-rmcp
+YTDL_RMCP_RELEASE_BASE_URL=https://github.com/jmagar/ytdl-rmcp/releases/download npm i -g ytdl-rmcp
+YTDL_RMCP_SKIP_DOWNLOAD=1 npm i -g ytdl-rmcp
+```
+
+Supported binary targets are Linux x64 and Windows x64, matching the current
+GitHub Release assets.

package/bin/rytdl.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { binaryPath } = require("../lib/platform");
+
+function fail(message) {
+  process.stderr.write(`ytdl-rmcp: ${message}\n`);
+  process.exit(1);
+}
+
+const binary = binaryPath();
+
+if (!fs.existsSync(binary)) {
+  const installer = path.resolve(__dirname, "..", "scripts", "install.js");
+  const install = spawnSync(process.execPath, [installer], { stdio: "inherit" });
+  if (install.status !== 0) {
+    fail("binary is not installed; postinstall may have failed");
+  }
+}
+
+const child = spawnSync(binary, process.argv.slice(2), { stdio: "inherit" });
+
+if (child.error) {
+  fail(child.error.message);
+}
+
+if (child.signal) {
+  process.kill(process.pid, child.signal);
+} else {
+  process.exit(child.status ?? 1);
+}

package/lib/platform.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const path = require("node:path");
+
+function packageVersion() {
+  return require("../package.json").version;
+}
+
+function targetFor(platform = process.platform, arch = process.arch) {
+  if (platform === "linux" && arch === "x64") {
+    return {
+      asset: "rytdl-x86_64.tar.gz",
+      binary: "rytdl",
+    };
+  }
+
+  if (platform === "win32" && arch === "x64") {
+    return {
+      asset: "rytdl-windows-x86_64.tar.gz",
+      binary: "rytdl.exe",
+    };
+  }
+
+  throw new Error(`Unsupported platform ${platform}/${arch}. Supported targets: linux/x64, win32/x64.`);
+}
+
+function releaseVersion(env = process.env) {
+  const raw = env.YTDL_RMCP_BINARY_VERSION || packageVersion();
+  return raw.startsWith("v") ? raw : `v${raw}`;
+}
+
+function releaseBaseUrl(env = process.env) {
+  return env.YTDL_RMCP_RELEASE_BASE_URL || "https://github.com/jmagar/ytdl-rmcp/releases/download";
+}
+
+function downloadUrl(target, env = process.env) {
+  return `${releaseBaseUrl(env)}/${releaseVersion(env)}/${target.asset}`;
+}
+
+function installRoot() {
+  return path.resolve(__dirname, "..", "vendor");
+}
+
+function binaryPath(platform = process.platform, arch = process.arch) {
+  const target = targetFor(platform, arch);
+  return path.join(installRoot(), target.binary);
+}
+
+module.exports = {
+  binaryPath,
+  downloadUrl,
+  installRoot,
+  packageVersion,
+  releaseVersion,
+  targetFor,
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "ytdl-rmcp",
+  "version": "0.7.1",
+  "description": "Node launcher for the ytdl-rmcp Rust MCP server and CLI binary.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jmagar/ytdl-rmcp.git",
+    "directory": "packages/ytdl-rmcp"
+  },
+  "bin": {
+    "ytdl-rmcp": "bin/rytdl.js",
+    "rytdl": "bin/rytdl.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "test": "node --test",
+    "check": "node --check bin/rytdl.js && node --check scripts/install.js && node --check lib/platform.js"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const http = require("node:http");
+const https = require("node:https");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const {
+  binaryPath,
+  downloadUrl,
+  installRoot,
+  releaseVersion,
+  targetFor,
+} = require("../lib/platform");
+
+function log(message) {
+  process.stderr.write(`ytdl-rmcp: ${message}\n`);
+}
+
+function download(url, destination) {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith("http:") ? http : https;
+    const request = client.get(url, (response) => {
+      if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
+        response.resume();
+        download(response.headers.location, destination).then(resolve, reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`download failed (${response.statusCode}) from ${url}`));
+        return;
+      }
+
+      const file = fs.createWriteStream(destination, { mode: 0o600 });
+      response.pipe(file);
+      file.on("finish", () => file.close(resolve));
+      file.on("error", reject);
+    });
+
+    request.on("error", reject);
+  });
+}
+
+function extract(archive, destination) {
+  fs.rmSync(destination, { recursive: true, force: true });
+  fs.mkdirSync(destination, { recursive: true });
+
+  const result = spawnSync("tar", ["-xzf", archive, "-C", destination], {
+    encoding: "utf8",
+  });
+
+  if (result.status !== 0) {
+    throw new Error((result.stderr || result.stdout || "tar extraction failed").trim());
+  }
+}
+
+async function main() {
+  if (process.env.YTDL_RMCP_SKIP_DOWNLOAD === "1") {
+    log("skipping binary download because YTDL_RMCP_SKIP_DOWNLOAD=1");
+    return;
+  }
+
+  const target = targetFor();
+  const destination = binaryPath();
+
+  if (fs.existsSync(destination)) {
+    log(`${path.basename(destination)} already installed for ${releaseVersion()}`);
+    return;
+  }
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ytdl-rmcp-install-"));
+  const archive = path.join(tempDir, target.asset);
+
+  try {
+    const url = downloadUrl(target);
+    log(`downloading ${url}`);
+    await download(url, archive);
+    extract(archive, installRoot());
+    fs.chmodSync(destination, 0o755);
+    log(`installed ${destination}`);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  log(error.message);
+  process.exitCode = 1;
+});