@liase/cli 1.0.0

package/dist/subcommands/run.js

@@ -0,0 +1,123 @@
+import { Command, Option } from "commander";
+import open from "open";
+import { getLiaseDetailsFromArgs, getRequestFromArgs, getSharedLiaseOptions, } from "../lib/liase-details.js";
+import { getLiaseQuery } from "../lib/liase-query.js";
+import { startProxyServer } from "../lib/proxy.js";
+import { zodSchemaToSimpleSchema } from "../lib/zod.js";
+export async function getRunCommand() {
+    const runCommand = new Command();
+    const liaseDetails = await getLiaseDetailsFromArgs();
+    const { sourceOption, requestHandlerOption, pluginsOption, cacheNetworkRequestsOption, secretsSetOption, } = getSharedLiaseOptions(liaseDetails);
+    runCommand
+        .name("run")
+        .addOption(sourceOption)
+        .addOption(requestHandlerOption)
+        .addOption(pluginsOption)
+        .addOption(cacheNetworkRequestsOption)
+        .addOption(secretsSetOption)
+        .addOption(new Option("-f, --outputFormat <output format>", `"JSON" will format the output as JSON, "pretty" will format the output in a more human readable way with syntax highlighting, ` +
+        `"online" will open a webpage with the results visible. Default is "pretty" unless output is being piped in which case the default is "json".`)
+        .choices(["json", "pretty", "online"])
+        .default(process.stdout.isTTY ? "pretty" : "json"))
+        .action(async (options) => {
+        const { outputFormat, cacheNetworkRequests, secretsSet } = options;
+        const request = getRequestFromArgs(options, liaseDetails.requestHandler);
+        const query = await getLiaseQuery({
+            request,
+            loadPluginsFromArgs: true,
+            cacheNetworkRequests,
+            secretsSet,
+        });
+        const response = await query.getNext();
+        if (response === null) {
+            throw Error("No response received");
+        }
+        if (outputFormat === "pretty") {
+            console.dir(response, { depth: null });
+        }
+        else if (outputFormat === "json") {
+            console.log(JSON.stringify(response, null, 2));
+        }
+        else if (outputFormat === "online") {
+            const { origin: proxyOrigin } = await startProxyServer();
+            for (const media of response.media || []) {
+                for (const file of media.files || []) {
+                    file.url = `${proxyOrigin}/${file.url}`;
+                }
+            }
+            const res = await fetch("https://mediafinderviewer.cals.cafe/api/output", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(response),
+            });
+            const data = await res.json();
+            if (data &&
+                typeof data === "object" &&
+                "viewerUrl" in data &&
+                typeof data.viewerUrl === "string") {
+                open(data.viewerUrl);
+            }
+            else {
+                throw Error("Invalid response for server");
+            }
+        }
+        else {
+            throw Error(`Unknown output format "${outputFormat}"`);
+        }
+    });
+    const { requestHandler } = liaseDetails;
+    if (requestHandler) {
+        const simpleSchema = zodSchemaToSimpleSchema(requestHandler.requestSchema);
+        if (simpleSchema.type !== "object") {
+            throw Error("Internal error: Request schema was not an object");
+        }
+        const requestOpts = Object.entries(simpleSchema.children);
+        for (const [name, requestOption] of requestOpts) {
+            if (["source", "queryType"].includes(name))
+                continue;
+            let valueType;
+            let valueParser = undefined;
+            let choices = undefined;
+            if (Array.isArray(requestOption.type)) {
+                if (requestOption.type.every((subtype) => subtype.type === "literal")) {
+                    choices = requestOption.type.map((unionSubtype) => String(unionSubtype.value));
+                    // Add all subtypes to a set to work out the list of unique subtypes
+                    const unionSubtypes = new Set(requestOption.type.map((subtype) => subtype.valueType));
+                    valueType = [...unionSubtypes].join(" | ");
+                }
+                else {
+                    // TODO: Deal with this case
+                    valueType = "unknown";
+                }
+            }
+            else {
+                valueType = requestOption.type;
+            }
+            if (valueType === "number") {
+                valueParser = Number.parseFloat;
+            }
+            const flagDetails = valueType === "boolean" ? `--${name}` : `--${name} <${valueType}>`;
+            const description = [
+                requestOption.description,
+                requestOption.optional ? undefined : "(required)",
+            ]
+                .filter((part) => part)
+                .join(" ");
+            const option = new Option(flagDetails, description);
+            if (requestOption.default !== undefined) {
+                option.default(requestOption.default);
+            }
+            option.makeOptionMandatory(!requestOption.optional);
+            if (valueParser) {
+                option.argParser(valueParser);
+            }
+            if (choices) {
+                option.choices(choices);
+            }
+            runCommand.addOption(option);
+        }
+    }
+    return runCommand;
+}

package/dist/subcommands/show-schema.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function getShowSchemaCommand(): Promise<Command>;
+//# sourceMappingURL=show-schema.d.ts.map

package/dist/subcommands/show-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show-schema.d.ts","sourceRoot":"","sources":["../../src/subcommands/show-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAS5C,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CA6C7D"}

package/dist/subcommands/show-schema.js

@@ -0,0 +1,44 @@
+import { Command, Option } from "commander";
+import { z } from "zod";
+import { getLiaseDetailsFromArgs, getSharedLiaseOptions, } from "../lib/liase-details.js";
+import { getLiaseQuery } from "../lib/liase-query.js";
+import { zodSchemaToSimpleSchema } from "../lib/zod.js";
+export async function getShowSchemaCommand() {
+    const showSchemaCommand = new Command();
+    const liaseDetails = await getLiaseDetailsFromArgs();
+    const { sourceOption, requestHandlerOption, pluginsOption } = getSharedLiaseOptions(liaseDetails);
+    const { requestHandler } = liaseDetails;
+    showSchemaCommand
+        .name("show-schema")
+        .addOption(sourceOption)
+        .addOption(requestHandlerOption)
+        .addOption(new Option("-t, --schemaType <schemaType>", 'Type of schema to return. If type is "response" then any required request options must be given in order to determine which response schema will be returned')
+        .choices(["request", "secrets", "response"])
+        .default("response"))
+        .action(async (options) => {
+        if (!requestHandler) {
+            throw Error("Internal error: Trying to show schema without request handler being set first");
+        }
+        let schema;
+        if (options.schemaType === "request") {
+            schema = requestHandler.requestSchema;
+        }
+        else if (options.schemaType === "secrets") {
+            schema = requestHandler.secretsSchema || z.object({}).strict();
+        }
+        else if (options.schemaType === "response") {
+            const { plugins, outputFormat, request } = options;
+            const liaseQuery = await getLiaseQuery({
+                request,
+                loadPluginsFromArgs: true,
+            });
+            schema = liaseQuery.getResponseDetails().schema;
+        }
+        else {
+            throw Error(`Unknown schema type option "${options.schemaType}"`);
+        }
+        const simpleSchema = zodSchemaToSimpleSchema(schema);
+        console.dir(simpleSchema, { depth: null });
+    });
+    return showSchemaCommand;
+}

package/dist/subcommands/web-ui.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function getWebUiCommand(): Promise<Command>;
+//# sourceMappingURL=web-ui.d.ts.map

package/dist/subcommands/web-ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-ui.d.ts","sourceRoot":"","sources":["../../src/subcommands/web-ui.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,wBAAsB,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC,CAUxD"}

package/dist/subcommands/web-ui.js

@@ -0,0 +1,137 @@
+import fs from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import util from "node:util";
+import AnsiToHtml from "ansi-to-html";
+import { Command } from "commander";
+import mimeTypes from "mime-types";
+import { getSharedLiaseOptions } from "../lib/liase-details.js";
+import { getLiaseQuery } from "../lib/liase-query.js";
+import { getSecretsSets } from "../lib/secrets.js";
+export async function getWebUiCommand() {
+    const webUiCommand = new Command();
+    const { pluginsOption } = getSharedLiaseOptions({ plugins: [] });
+    webUiCommand
+        .name("web-ui")
+        .addOption(pluginsOption)
+        .action(async () => {
+        await startServer();
+    });
+    return webUiCommand;
+}
+function startServer() {
+    const buildId = Date.now();
+    const server = http
+        .createServer(async (req, res) => {
+        if (req.method === "GET" && req.url === "/build-id") {
+            res.writeHead(200, {
+                "Content-Type": "text/application/json",
+                "Access-Control-Allow-Origin": "*",
+            });
+            res.end(JSON.stringify(buildId));
+        }
+        else if (req.method === "GET" && req.url === "/secrets-sets") {
+            return handleSecretSetsRequest(req, res);
+        }
+        else if (req.method === "POST") {
+            console.log(`${req.method} ${req.url}`);
+            return handleMediaQueryRequest(req, res);
+        }
+        else if (req.method === "GET") {
+            console.log(`${req.method} ${req.url}`);
+            return handleStaticFileRequest(req, res);
+        }
+    })
+        .listen(4000);
+    function cleanup() {
+        server.close();
+    }
+    process.on("SIGINT", cleanup);
+    process.on("SIGQUIT", cleanup);
+    process.on("SIGTERM", cleanup);
+    const serverAddress = server.address();
+    console.log("Server listening:", `http://localhost:${typeof serverAddress === "object" && serverAddress?.port}`);
+    return new Promise((resolve, reject) => {
+        server.on("close", resolve);
+    });
+}
+async function handleSecretSetsRequest(req, res) {
+    const secretSets = await getSecretsSets();
+    res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+    });
+    res.end(JSON.stringify(Object.keys(secretSets)));
+}
+function handleMediaQueryRequest(req, res) {
+    let body = "";
+    req.on("data", (chunk) => {
+        body += chunk;
+    });
+    req.on("end", async () => {
+        const { mediaFinderRequest, secretsSet, cacheNetworkRequests } = JSON.parse(body);
+        let response;
+        try {
+            const query = await getLiaseQuery({
+                request: mediaFinderRequest,
+                secretsSet,
+                loadPluginsFromArgs: true,
+                cacheNetworkRequests,
+            });
+            response = await query.getNext();
+        }
+        catch (error) {
+            res.writeHead(400, {
+                "Content-Type": "text/application/json",
+                "Access-Control-Allow-Origin": "*",
+            });
+            const errorString = new AnsiToHtml({
+                fg: "#000",
+                bg: "#888",
+                newline: true,
+            }).toHtml(util.inspect(error));
+            console.log(error);
+            res.end(JSON.stringify({ error: errorString }));
+            return;
+        }
+        res.writeHead(200, {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*",
+        });
+        res.end(JSON.stringify(response));
+    });
+}
+async function handleStaticFileRequest(req, res) {
+    // parse URL
+    const parsedUrl = new URL(req.url || "", "http://domain");
+    const sanitizePath = path
+        .normalize(parsedUrl.pathname)
+        .replace(/^(\.\.[/\\])+/, "");
+    let pathname = path.join(import.meta.dirname, "../web-ui", sanitizePath);
+    try {
+        await fs.access(pathname);
+    }
+    catch (error) {
+        // if the file is not found, return 404
+        res.statusCode = 404;
+        res.end(`File ${pathname} not found!`);
+        return;
+    }
+    // if is a directory, then look for index.html
+    if ((await fs.stat(pathname)).isDirectory()) {
+        pathname += "/index.html";
+    }
+    // read file from file system
+    try {
+        const data = await fs.readFile(pathname);
+        // based on the URL path, extract the file extension. e.g. .js, .doc, ...
+        const ext = path.parse(pathname).ext;
+        // if the file is found, set Content-type and send data
+        res.setHeader("Content-type", mimeTypes.lookup(ext) || "text/plain");
+        res.end(data);
+    }
+    catch (error) {
+        res.statusCode = 500;
+        res.end(`Error getting the file: ${error}.`);
+    }
+}

package/dist/web-ui/components/display-media.js

@@ -0,0 +1,19 @@
+import { toRefs } from "vue";
+import MediaPreview from "./media-preview.js";
+export default {
+  props: ["response"],
+  components: {
+    MediaPreview,
+  },
+  setup(props) {
+    const { response } = toRefs(props);
+    return { response };
+  },
+  template: /* html */ `
+    <ul class="DisplayMedia">
+      <li v-for="media in response.media" :key="media.id">
+        <media-preview :media="media" />
+      </li>
+    </ul>
+  `,
+};

package/dist/web-ui/components/media-preview.js

@@ -0,0 +1,132 @@
+import { computed, onMounted, ref, useTemplateRef } from "vue";
+import "hls.js";
+export default {
+  props: ["media"],
+  setup(props) {
+    const maxHeight = computed(() =>
+      Math.max(...props.media.files.map((file) => file.height || 0)),
+    );
+
+    const thumbnailDisplayHeight = 200;
+    const fileSortWeight = (file) => {
+      let weight = file.height
+        ? Math.abs(file.height - thumbnailDisplayHeight) /
+          Math.max(maxHeight.value, thumbnailDisplayHeight)
+        : 1;
+      if (!file.hasVideo) weight += 1;
+      return weight;
+    };
+
+    const mediaAsset = computed(
+      () =>
+        (props.media.assets?.media || props.media.files || []).toSorted(
+          (a, b) =>
+            // Listed in order of importance from most important to least important
+            (b.videoCodec !== "hevc") - (a.videoCodec !== "hevc") || // Non-hevc streams preferred
+            (b.isOriginalTranscode ?? false) -
+              (a.isOriginalTranscode ?? false) || // isOriginalTranscode preferred
+            (b.mimeType === "application/vnd.apple.mpegurl") -
+              (a.mimeType === "application/vnd.apple.mpegurl") || // HLS preferred
+            (b.isOriginalResolution ?? false) -
+              (a.isOriginalResolution ?? false) || // isOriginalResolution preferred
+            (b.duration ?? 0) - (a.duration ?? 0), // duration descending
+        )[0],
+    );
+
+    const previewAsset = computed(
+      () =>
+        (
+          props.media.assets?.preview ||
+          props.media.files?.filter((file) => file.image) ||
+          []
+        ).toSorted(
+          (a, b) =>
+            // Listed in order of importance from most important to least important
+            fileSortWeight(a) - fileSortWeight(b), // How close the size it to the displayed size from closest to furthest
+        )[0],
+    );
+
+    const displayElement = computed(() =>
+      mediaAsset.value?.video && mediaAsset.value?.ext !== "gif"
+        ? "video"
+        : "image",
+    );
+
+    const videoRef = useTemplateRef("video-elm");
+
+    onMounted(() => {
+      const file = mediaAsset.value;
+
+      if (!file || videoRef.value === null) {
+        return;
+      }
+
+      if (file.ext === "m3u8") {
+        if (videoRef.value.canPlayType("application/vnd.apple.mpegurl")) {
+          videoRef.value.src = file.url;
+        } else if (window.Hls.isSupported()) {
+          const hls = new window.Hls();
+          hls.loadSource(file.url);
+          hls.attachMedia(videoRef.value);
+        } else {
+          throw Error("Browser can't play HLS");
+        }
+      } else {
+        videoRef.value.src = file.url;
+      }
+    });
+
+    const hoverOverPlayCountdown = ref(null);
+    function handleMouseEnter() {
+      hoverOverPlayCountdown.value = setTimeout(
+        () => videoRef.value?.play(),
+        300,
+      );
+    }
+    function handleMouseLeave() {
+      clearTimeout(hoverOverPlayCountdown.value);
+      videoRef.value?.pause();
+    }
+    return {
+      displayElement,
+      mediaAsset,
+      previewAsset,
+      handleMouseEnter,
+      handleMouseLeave,
+    };
+  },
+  template: /* html */ `
+    <div
+      class="MediaPreview"
+    >
+			<div
+				v-if="displayElement === 'video'"
+				class="videoContainer"
+			>
+				<video
+					ref="video-elm"
+					preload="none"
+					playsinline="true"
+					muted="true"
+					:poster="previewAsset?.url"
+					:style="mediaAsset.aspectRatio ? {'aspect-ratio': mediaAsset.aspectRatio.width + ' / ' + mediaAsset.aspectRatio.height} : {}"
+					controls="true"
+				></video>
+				<img
+					v-if="previewAsset"
+					:src="previewAsset?.url"
+				>
+			</div>
+      <img
+        v-else-if="displayElement === 'image'"
+        :src="mediaAsset?.url"
+      >
+      <div v-else>
+        Unknown display type {{ displayElement }}
+      </div>
+      <div class="info">
+        {{ media.title }}
+      </div>
+    </div>
+  `,
+};

package/dist/web-ui/components/page.js

@@ -0,0 +1,205 @@
+import { computed, ref, useTemplateRef, watch } from "vue";
+import DisplayMedia from "./display-media.js";
+import "@alenaksu/json-viewer";
+export default {
+  components: {
+    DisplayMedia,
+  },
+  setup() {
+    const emptyQuery = {
+      id: Date.now(),
+      name: "untitled query",
+      requestString: "{}",
+      secretsSet: "",
+      cacheNetworkRequests: "always",
+    };
+    const queries = ref(
+      JSON.parse(
+        localStorage.getItem("queries") || JSON.stringify([emptyQuery]),
+      ),
+    );
+    watch(
+      queries,
+      () => localStorage.setItem("queries", JSON.stringify(queries.value)),
+      { deep: true },
+    );
+
+    const currentQueryId = ref(
+      JSON.parse(localStorage.getItem("currentQueryId")) ||
+        queries.value[0]?.id,
+    );
+    watch(currentQueryId, () => {
+      localStorage.setItem("currentQueryId", currentQueryId.value);
+    });
+
+    const currentQuery = computed(() => {
+      const currentQuery = queries.value?.find(
+        (query) => query.id === currentQueryId.value,
+      );
+      if (!currentQuery) {
+        console.info("Queries", queries.value);
+        if (queries.value?.length) {
+          console.warn(
+            "Could not find current query with id:",
+            currentQueryId.value,
+          );
+          const firstQuery = queries.value[0];
+          currentQueryId.value = firstQuery.id;
+          return firstQuery;
+        }
+        throw Error(
+          `Could not find current query with id: ${currentQueryId.value}`,
+        );
+      }
+      return currentQuery;
+    });
+
+    const secretsSets = ref([]);
+    async function updateSecretsSets() {
+      const res = await fetch("/secrets-sets");
+      secretsSets.value = await res.json();
+    }
+    updateSecretsSets();
+
+    const requestValid = computed(() => {
+      try {
+        JSON.parse(currentQuery.value?.requestString);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    });
+    const responseView = ref(localStorage.getItem("responseView") || "visual");
+    watch(responseView, () => {
+      localStorage.setItem("responseView", responseView.value);
+    });
+    const response = ref("");
+    const loadingStatus = ref("finished");
+    async function fetchMedia() {
+      loadingStatus.value = "loading";
+      try {
+        const res = await fetch("/", {
+          method: "POST",
+          body: JSON.stringify({
+            mediaFinderRequest: JSON.parse(currentQuery.value?.requestString),
+            secretsSet: currentQuery.value?.secretsSet,
+            cacheNetworkRequests: currentQuery.value?.cacheNetworkRequests,
+          }),
+        });
+        response.value = await res.json();
+        if (res.ok) {
+          loadingStatus.value = "finished";
+        } else {
+          loadingStatus.value = "error";
+        }
+      } catch (error) {
+        loadingStatus.value = "error";
+        response.value = { error };
+      }
+    }
+    fetchMedia();
+
+    function duplicateQuery() {
+      const clonedCurrentQuery = JSON.parse(JSON.stringify(currentQuery.value));
+      const newQuery = {
+        ...clonedCurrentQuery,
+        id: Date.now(),
+      };
+      queries.value.push(newQuery);
+      currentQueryId.value = newQuery.id;
+    }
+
+    function handleRequestChange(event) {
+      currentQuery.value.requestString = JSON.stringify(
+        JSON.parse(event.target.value),
+        null,
+        2,
+      );
+    }
+
+    const jsonViewerRef = useTemplateRef("json-viewer");
+
+    watch([response, responseView], () => {
+      if (responseView.value === "json") {
+        setTimeout(() => {
+          jsonViewerRef.value?.expand("media.0");
+        }, 100);
+      }
+    });
+    return {
+      response,
+      fetchMedia,
+      responseView,
+      requestValid,
+      loadingStatus,
+      handleRequestChange,
+      secretsSets,
+      currentQuery,
+      currentQueryId,
+      queries,
+      duplicateQuery,
+    };
+  },
+  template: /* html */ `
+    <div class="options">
+			<div class="group">
+				<div class="group">
+					<label for="current-query">Current query:</label>
+					<select name="current-query" id="current-query" v-model="currentQueryId">
+						<option v-for="query, index in queries" :value="query.id">{{index}} - {{query.name}}</option>
+					</select>
+				</div>
+				<div class="group">
+					<label for="query-name">Query name:</label>
+					<input name="query-name" id="query-name" v-model="currentQuery.name" />
+					</div>
+				<button @click="duplicateQuery">Duplicate query</button>
+			</div>
+      <textarea
+        :style="{'background-color': requestValid ? 'rgba(56, 255, 0, 0.06)' : '#ff00001a'}"
+        id="request"
+        v-model="currentQuery.requestString"
+        @change="handleRequestChange"
+      ></textarea>
+			<div class="group">
+				<div class="group">
+					<label for="secret-set">Secrets Set:</label>
+					<select name="secret-set" id="secret-set" v-model="currentQuery.secretsSet">
+						<option value="">--None--</option>
+						<option v-for="secretsSet in secretsSets" :value="secretsSet">{{secretsSet}}</option>
+					</select>
+				</div>
+				<div class="group">
+					<label for="cache-network-requests">Cache Network Requests:</label>
+					<select name="cache-network-requests" id="cache-network-requests" v-model="currentQuery.cacheNetworkRequests">
+						<option value="never">Never</option>
+						<option value="auto">Auto</option>
+						<option value="always">Always</option>
+					</select>
+				</div>
+				<button @click="fetchMedia" :disabled="!requestValid">Fetch</button>
+			</div>
+    </div>
+    <div class="buttons">
+      <button @click="responseView = responseView === 'json' ? 'visual' : 'json'">Show {{responseView === 'json' ? 'Media' : 'JSON'}}</button>
+    </div>
+		<div v-if="loadingStatus !== 'finished'">{{loadingStatus}}</div>
+		<div
+			v-if="loadingStatus === 'error'"
+		>
+			<pre class="error" v-html="response?.error"></pre>
+		</div>
+		<template v-else>
+			<json-viewer
+				v-if="responseView === 'json'"
+				id="response"
+				:data="response"
+				ref="json-viewer"
+			/>
+			<display-media
+				v-else
+				:response="response"
+			/>
+		</template>
+  `,
+};