@streamfox/create-streamfox-plugin 0.3.0

package/dist/cli.cjs

@@ -0,0 +1,637 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_path2 = __toESM(require("path"), 1);
+var import_commander = require("commander");
+var import_prompts = __toESM(require("prompts"), 1);
+
+// package.json
+var package_default = {
+  name: "@streamfox/create-streamfox-plugin",
+  version: "0.3.0",
+  description: "Standalone CLI to scaffold StreamFox plugin projects",
+  type: "module",
+  bin: {
+    "create-streamfox-plugin": "dist/cli.cjs"
+  },
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    }
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  scripts: {
+    build: "tsup",
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    test: "vitest run",
+    typecheck: "tsc --noEmit",
+    check: "npm run format:check && npm run typecheck && npm test && npm run build"
+  },
+  dependencies: {
+    commander: "^12.1.0",
+    prompts: "^2.4.2"
+  },
+  devDependencies: {
+    "@types/node": "^24.6.0",
+    "@types/prompts": "^2.4.9",
+    prettier: "^3.6.2",
+    tsup: "^8.5.0",
+    typescript: "^5.9.2",
+    vitest: "^2.1.9"
+  },
+  engines: {
+    node: ">=20"
+  }
+};
+
+// src/scaffold.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var CAPABILITIES = [
+  "catalog",
+  "meta",
+  "stream",
+  "subtitles",
+  "plugin_catalog"
+];
+var DEFAULT_PRESET = "meta";
+var DEFAULT_SDK_VERSION = "^0.2.0";
+function sortedCapabilities(values) {
+  const unique = Array.from(new Set(values));
+  return CAPABILITIES.filter((capability) => unique.includes(capability));
+}
+async function ensureTargetDoesNotExist(targetDir) {
+  try {
+    await (0, import_promises.access)(targetDir);
+    throw new Error(`Target directory already exists: ${targetDir}`);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+function makePackageJson(name, language, sdkVersion) {
+  const scripts = language === "ts" ? {
+    dev: "tsx watch src/server.ts",
+    build: "tsc -p tsconfig.json",
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    start: "node dist/server.js",
+    test: "vitest run",
+    typecheck: "tsc --noEmit"
+  } : {
+    dev: "node --watch src/server.js",
+    build: 'echo "No build step for JavaScript template"',
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    start: "node src/server.js",
+    test: "vitest run"
+  };
+  const normalizedScripts = {
+    ...scripts,
+    check: language === "ts" ? "npm run format:check && npm run typecheck && npm test && npm run build" : "npm run format:check && npm test && npm run build"
+  };
+  const packageJson = {
+    name,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: normalizedScripts,
+    dependencies: {
+      "@streamfox/plugin-sdk": sdkVersion
+    },
+    devDependencies: language === "ts" ? {
+      "@types/node": "^24.6.0",
+      prettier: "^3.6.2",
+      tsx: "^4.20.5",
+      typescript: "^5.9.2",
+      vitest: "^2.1.9"
+    } : {
+      prettier: "^3.6.2",
+      vitest: "^2.1.9"
+    }
+  };
+  return `${JSON.stringify(packageJson, null, 2)}
+`;
+}
+function resourceBlock(capability, advanced) {
+  switch (capability) {
+    case "catalog":
+      return `catalog: {
+      endpoints: [
+        {
+          id: "top",
+          name: "Top",
+          mediaTypes: ["movie"],
+          filters: [{ key: "genre", valueType: "string" }],
+        },
+      ],
+      handler: async () => ({
+        items: [],
+      }),
+    },`;
+    case "meta":
+      return `meta: {
+      mediaTypes: ["movie"],
+      includes: ["videos", "links"],
+      handler: async () => ({
+        item: ${advanced ? `{
+          summary: {
+            id: { namespace: "imdb", value: "tt1254207" },
+            mediaType: "movie",
+            title: "Big Buck Bunny",
+            links: [],
+          },
+          defaultVideoID: "main",
+          trailers: [{ transport: { kind: "youtube", id: "aqz-KE-bpKQ" } }],
+          videos: [
+            {
+              id: "main",
+              title: "Main",
+              streams: [{ transport: { kind: "http", url: "https://example.com/video.mp4" } }],
+            },
+          ],
+        }` : "null"},
+      }),
+    },`;
+    case "stream":
+      return `stream: {
+      mediaTypes: ["movie"],
+      supportedTransports: ${advanced ? `["http", "torrent", "usenet", "archive", "youtube"]` : `["http"]`},
+      handler: async () => ({
+        streams: [
+          {
+            transport: { kind: "http", url: "https://example.com/video.mp4", mode: "stream" },
+            hints: {
+              notWebReady: true,
+              proxyHeaders: { request: { "User-Agent": "StreamFox" } },
+            },
+          },
+${advanced ? `          {
+            transport: { kind: "torrent", infoHash: "abcdef", peerDiscovery: ["tracker:udp://tracker.example.com:80"] },
+            selection: { fileIndex: 0 },
+          },
+          {
+            transport: { kind: "usenet", nzbURL: "https://example.com/file.nzb", servers: ["nntps://user:pass@news.example.com:563/4"] },
+          },
+          {
+            transport: {
+              kind: "archive",
+              format: "zip",
+              files: [{ url: "https://example.com/archive.zip", bytes: 1024 }],
+            },
+            selection: { fileMustInclude: "movie.mkv" },
+          },
+` : ""}        ],
+      }),
+    },`;
+    case "subtitles":
+      return `subtitles: {
+      mediaTypes: ["movie", "episode"],
+      defaultLanguages: ["en"],
+      handler: async (request, { settings }) => {
+        const configuredLanguages = Array.isArray(settings.languages)
+          ? settings.languages
+          : [];
+        const languagePreferences =
+          configuredLanguages.length > 0 ? configuredLanguages : (request.languagePreferences ?? []);
+
+        void languagePreferences;
+        void settings.includeHI;
+
+        return {
+          subtitles: [],
+        };
+      },
+    },`;
+    case "plugin_catalog":
+      return `pluginCatalog: {
+      endpoints: [
+        {
+          id: "featured",
+          name: "Featured",
+          pluginKinds: ["catalog", "meta", "stream", "subtitles"],
+          tags: ["official"],
+        },
+      ],
+      handler: async () => ({
+        plugins: [
+          {
+            id: "com.example.recommended",
+            name: "Recommended",
+            version: "1.0.0",
+            pluginKinds: ["catalog", "meta"],
+            distribution: {
+              transport: "https",
+              manifestURL: "https://plugins.example.com/recommended/manifest",
+            },
+            manifestSnapshot: {
+              plugin: { id: "com.example.recommended" },
+            },
+          },
+        ],
+      }),
+    },`;
+    default:
+      return "";
+  }
+}
+function makeInstallBlock(preset) {
+  if (preset !== "subtitles") {
+    return "";
+  }
+  return `  install: {
+    configurationRequired: true,
+    title: "Subtitle Settings",
+    description: "Configure subtitle defaults before installing this plugin.",
+    fields: [
+      settings.multiSelect("languages", {
+        label: "Languages",
+        options: [
+          { label: "English", value: "en" },
+          { label: "Greek", value: "el" },
+          { label: "Spanish", value: "es" },
+        ],
+        defaultValue: ["en"],
+      }),
+      settings.checkbox("includeHI", {
+        label: "Include hearing impaired",
+        defaultValue: true,
+      }),
+    ],
+  },
+`;
+}
+function makePluginFile(name, preset, capabilities, advanced) {
+  const resources = capabilities.map((capability) => resourceBlock(capability, advanced)).join("\n    ");
+  const install = makeInstallBlock(preset);
+  const importSpec = install.length > 0 ? "definePlugin, settings" : "definePlugin";
+  const installBlock = install.length > 0 ? `${install}` : "";
+  return `import { ${importSpec} } from "@streamfox/plugin-sdk";
+
+export const plugin = definePlugin({
+  plugin: {
+    id: "com.example.${name}",
+    name: "${name}",
+    version: "0.1.0",
+    description: "Generated StreamFox plugin scaffold",
+  },
+${installBlock}  resources: {
+    ${resources}
+  },
+});
+`;
+}
+function makeServerFile(language) {
+  const pluginImport = language === "ts" ? "./plugin" : "./plugin.js";
+  return `import { serve } from "@streamfox/plugin-sdk";
+import { plugin } from "${pluginImport}";
+
+const { url, installURL, launchURL } = await serve(plugin, {
+  port: Number(process.env.PORT ?? 7000),
+  integration: {
+    installScheme: "streamfox",
+    launchBaseURL: "https://streamfox.app/#",
+    autoOpen: "none",
+  },
+});
+
+console.log("Plugin manifest:", url);
+console.log("Plugin installer deeplink:", installURL);
+console.log("Plugin launch URL:", launchURL);
+`;
+}
+function makeVitestFile(language) {
+  const pluginImport = language === "ts" ? "../src/plugin" : "../src/plugin.js";
+  return `import { describe, expect, it } from "vitest";
+import { createServer } from "@streamfox/plugin-sdk";
+import { plugin } from "${pluginImport}";
+
+describe("scaffold smoke", () => {
+  it("serves manifest and studio config", async () => {
+    const app = createServer(plugin, { frontend: false });
+
+    const manifestResponse = await app.request("/manifest");
+    expect(manifestResponse.status).toBe(200);
+
+    const studioResponse = await app.request("/studio-config");
+    expect(studioResponse.status).toBe(200);
+  });
+});
+`;
+}
+var tsConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["node"]
+  },
+  "include": ["src"]
+}
+`;
+var prettierConfig = `{
+  "semi": true,
+  "singleQuote": false,
+  "trailingComma": "all"
+}
+`;
+var prettierIgnore = `dist
+node_modules
+.DS_Store
+`;
+function makeReadme(projectName, preset, capabilities, advanced) {
+  const capabilitiesList = capabilities.map((capability) => `- ${capability}`).join("\n");
+  const endpointForCapability = (capability) => {
+    switch (capability) {
+      case "catalog":
+        return "/catalog/:mediaType/:catalogID";
+      case "meta":
+        return "/meta/:mediaType/:itemID";
+      case "stream":
+        return "/stream/:mediaType/:itemID";
+      case "subtitles":
+        return "/subtitles/:mediaType/:itemID";
+      case "plugin_catalog":
+        return "/plugin_catalog/:catalogID/:pluginKind";
+      default:
+        return `/${capability}`;
+    }
+  };
+  const endpointLines = [
+    "- GET /manifest",
+    "- GET /studio-config",
+    ...capabilities.map(
+      (capability) => `- GET ${endpointForCapability(capability)}`
+    )
+  ].join("\n");
+  return `# ${projectName}
+
+Generated with create-streamfox-plugin.
+
+Preset: \`${preset}\`
+Advanced template: \`${advanced ? "enabled" : "disabled"}\`
+
+## Scripts
+
+- npm run dev
+- npm run build
+- npm run format
+- npm run start
+- npm run test
+
+## Implemented Capabilities
+
+${capabilitiesList}
+
+## Stream Model
+
+- Unified transport model via \`stream.transport\`
+- Capability declaration via \`resources.stream.supportedTransports\`
+- Optional selection controls via \`stream.selection\`
+
+## Endpoints
+
+${endpointLines}
+`;
+}
+async function scaffoldProject(options) {
+  const capabilities = sortedCapabilities([
+    options.preset,
+    ...options.extraCapabilities ?? []
+  ]);
+  const sdkVersion = (options.sdkVersion ?? DEFAULT_SDK_VERSION).trim() || DEFAULT_SDK_VERSION;
+  const advanced = options.advanced ?? false;
+  await ensureTargetDoesNotExist(options.targetDir);
+  const srcDir = import_node_path.default.join(options.targetDir, "src");
+  const testDir = import_node_path.default.join(options.targetDir, "test");
+  await (0, import_promises.mkdir)(srcDir, { recursive: true });
+  await (0, import_promises.mkdir)(testDir, { recursive: true });
+  await (0, import_promises.writeFile)(
+    import_node_path.default.join(options.targetDir, "package.json"),
+    makePackageJson(options.projectName, options.language, sdkVersion)
+  );
+  await (0, import_promises.writeFile)(
+    import_node_path.default.join(options.targetDir, ".prettierrc.json"),
+    prettierConfig
+  );
+  await (0, import_promises.writeFile)(
+    import_node_path.default.join(options.targetDir, ".prettierignore"),
+    prettierIgnore
+  );
+  await (0, import_promises.writeFile)(
+    import_node_path.default.join(options.targetDir, "README.md"),
+    makeReadme(options.projectName, options.preset, capabilities, advanced)
+  );
+  if (options.language === "ts") {
+    await (0, import_promises.writeFile)(import_node_path.default.join(options.targetDir, "tsconfig.json"), tsConfig);
+    await (0, import_promises.writeFile)(
+      import_node_path.default.join(srcDir, "plugin.ts"),
+      makePluginFile(
+        options.projectName,
+        options.preset,
+        capabilities,
+        advanced
+      )
+    );
+    await (0, import_promises.writeFile)(import_node_path.default.join(srcDir, "server.ts"), makeServerFile("ts"));
+    await (0, import_promises.writeFile)(import_node_path.default.join(testDir, "plugin.test.ts"), makeVitestFile("ts"));
+  } else {
+    await (0, import_promises.writeFile)(
+      import_node_path.default.join(srcDir, "plugin.js"),
+      makePluginFile(
+        options.projectName,
+        options.preset,
+        capabilities,
+        advanced
+      )
+    );
+    await (0, import_promises.writeFile)(import_node_path.default.join(srcDir, "server.js"), makeServerFile("js"));
+    await (0, import_promises.writeFile)(import_node_path.default.join(testDir, "plugin.test.js"), makeVitestFile("js"));
+  }
+}
+
+// src/cli.ts
+function capabilitiesLabel() {
+  return CAPABILITIES.join(", ");
+}
+function parsePreset(input) {
+  if (CAPABILITIES.includes(input)) {
+    return input;
+  }
+  throw new import_commander.InvalidArgumentError(
+    `Invalid preset '${input}'. Use one of: ${capabilitiesLabel()}`
+  );
+}
+function parseCapabilitiesList(input) {
+  const parsed = input.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+  for (const capability of parsed) {
+    if (!CAPABILITIES.includes(capability)) {
+      throw new import_commander.InvalidArgumentError(
+        `Invalid capability '${capability}'. Use one of: ${capabilitiesLabel()}`
+      );
+    }
+  }
+  return Array.from(new Set(parsed));
+}
+var program = new import_commander.Command();
+program.name("create-streamfox-plugin").version(package_default.version, "-v, --version", "display the current CLI version").description("Scaffold StreamFox plugin projects with modern JS/TS presets").showHelpAfterError().argument("[directory]", "output directory").option("--ts", "use TypeScript template").option("--js", "use JavaScript template").option(
+  "--preset <preset>",
+  `plugin preset: ${capabilitiesLabel()}`,
+  parsePreset
+).option(
+  "--capabilities <capabilities>",
+  "extra capabilities as comma-separated list",
+  parseCapabilitiesList
+).option("--advanced", "generate advanced capability examples").option(
+  "--sdk-version <range>",
+  "@streamfox/plugin-sdk version/range",
+  DEFAULT_SDK_VERSION
+).option("--yes", "skip prompts and use defaults").action(
+  async (directoryArg, options) => {
+    if (options.ts && options.js) {
+      throw new import_commander.InvalidArgumentError("Choose either --ts or --js, not both.");
+    }
+    const promptDefaults = {
+      directory: directoryArg ?? "my-media-plugin",
+      language: options.ts ? "ts" : options.js ? "js" : "ts",
+      preset: options.preset ?? DEFAULT_PRESET,
+      extraCapabilities: options.capabilities ?? [],
+      advanced: options.advanced ?? false,
+      sdkVersion: options.sdkVersion ?? DEFAULT_SDK_VERSION
+    };
+    const shouldPrompt = !options.yes;
+    let directory = promptDefaults.directory;
+    let language = promptDefaults.language;
+    let preset = promptDefaults.preset;
+    let extraCapabilities = promptDefaults.extraCapabilities;
+    let advanced = promptDefaults.advanced;
+    let sdkVersion = promptDefaults.sdkVersion;
+    if (shouldPrompt) {
+      const answers = await (0, import_prompts.default)(
+        [
+          {
+            type: "text",
+            name: "directory",
+            message: "Project directory",
+            initial: directory
+          },
+          {
+            type: "select",
+            name: "language",
+            message: "Template language",
+            choices: [
+              { title: "TypeScript", value: "ts" },
+              { title: "JavaScript", value: "js" }
+            ],
+            initial: language === "ts" ? 0 : 1
+          },
+          {
+            type: "select",
+            name: "preset",
+            message: "Plugin preset",
+            choices: CAPABILITIES.map((capability) => ({
+              title: capability,
+              value: capability
+            })),
+            initial: CAPABILITIES.indexOf(preset)
+          },
+          {
+            type: "multiselect",
+            name: "extraCapabilities",
+            message: "Extra capabilities (optional)",
+            choices: CAPABILITIES.map((capability) => ({
+              title: capability,
+              value: capability
+            })),
+            instructions: false,
+            min: 0,
+            hint: "Space to select"
+          },
+          {
+            type: "confirm",
+            name: "advanced",
+            message: "Generate advanced capability examples?",
+            initial: advanced
+          },
+          {
+            type: "text",
+            name: "sdkVersion",
+            message: "SDK dependency version/range",
+            initial: sdkVersion
+          }
+        ],
+        {
+          onCancel: () => {
+            process.exit(1);
+          }
+        }
+      );
+      directory = answers.directory;
+      language = answers.language;
+      preset = answers.preset ?? promptDefaults.preset;
+      extraCapabilities = answers.extraCapabilities ?? [];
+      advanced = Boolean(answers.advanced ?? promptDefaults.advanced);
+      sdkVersion = answers.sdkVersion ?? promptDefaults.sdkVersion;
+    }
+    const targetDir = import_node_path2.default.resolve(process.cwd(), directory);
+    const projectName = import_node_path2.default.basename(targetDir);
+    await scaffoldProject({
+      targetDir,
+      projectName,
+      language,
+      preset,
+      extraCapabilities,
+      advanced,
+      sdkVersion
+    });
+    console.log(`Created ${projectName} at ${targetDir}`);
+    console.log("Next steps:");
+    console.log(`  cd ${directory}`);
+    console.log("  npm install");
+    console.log("  npm run dev");
+  }
+);
+void program.parseAsync(process.argv).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Error: ${message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.cjs.map