@liase/cli 1.0.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright © 2024 Callum Gare
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+> :warning: **This package is currently experimental and the API is both poorly documented and likely to change**
+
+# liase CLI (`@liase/cli`)
+
+A CLI tool for [liase](https://github.com/callumgare/liase).

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { getRunCommand } from "./subcommands/run.js";
+import { getShowSchemaCommand } from "./subcommands/show-schema.js";
+import { getWebUiCommand } from "./subcommands/web-ui.js";
+const program = new Command();
+program.addCommand(await getRunCommand());
+program.addCommand(await getShowSchemaCommand());
+program.addCommand(await getWebUiCommand());
+program.parseAsync();

package/dist/lib/liase-details.d.ts

@@ -0,0 +1,18 @@
+import { type Plugin, type RequestHandler, type Source } from "@liase/core";
+import { Option } from "commander";
+type LiaseDetails = {
+    source?: Source;
+    requestHandler?: RequestHandler;
+    plugins: Plugin[];
+};
+export declare function getLiaseDetailsFromArgs(): Promise<LiaseDetails>;
+export declare function getSharedLiaseOptions({ source, plugins }: LiaseDetails): {
+    sourceOption: Option;
+    requestHandlerOption: Option;
+    pluginsOption: Option;
+    cacheNetworkRequestsOption: Option;
+    secretsSetOption: Option;
+};
+export declare function getRequestFromArgs(options: Record<string, unknown>, requestHandler?: RequestHandler): Record<string, unknown>;
+export {};
+//# sourceMappingURL=liase-details.d.ts.map

package/dist/lib/liase-details.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liase-details.d.ts","sourceRoot":"","sources":["../../src/lib/liase-details.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EACX,KAAK,cAAc,EACnB,KAAK,MAAM,EACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAW,MAAM,EAAE,MAAM,WAAW,CAAC;AAG5C,KAAK,YAAY,GAAG;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAgBF,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,YAAY,CAAC,CA+ErE;AAED,wBAAgB,qBAAqB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,YAAY;;;;;;EA6CtE;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASzB"}

package/dist/lib/liase-details.js

@@ -0,0 +1,105 @@
+import { Liase, } from "@liase/core";
+import { Command, Option } from "commander";
+import { tsImport } from "tsx/esm/api";
+// In order to add more details to the help text of some command and their arguments
+// we want to look some some details of some of the args the user may have given us.
+// For example if viewing the help text of the "run" command and they've also given
+// us the "--source" argument with the value "bluesky" then we want the list of valid
+// options for the "--requestHandler" to show only the request handlers provided by
+// the bluesky source. But to do this we need to first parse what options the user has
+// given us.
+// We normally can't do this before we define all the details for our commands
+// so to get around this we create a "shadow" command object with the subcommands and
+// subcommand options we care about, parse this in order to determine which values
+// the user has given us, then finally we lookup any relevant info based on this and
+// return it so it can be used for building our actual options.
+let cachedLiaseDetails = undefined;
+export async function getLiaseDetailsFromArgs() {
+    if (!cachedLiaseDetails) {
+        const program = new Command();
+        const silenceCommand = (command) => command
+            .helpCommand(false)
+            .helpOption("")
+            .exitOverride()
+            .configureOutput({
+            writeOut: () => { },
+            writeErr: () => { },
+            outputError: () => { },
+        })
+            .allowUnknownOption();
+        silenceCommand(program);
+        let options = {};
+        function addSubcommand(program, subcommandName) {
+            const command = new Command();
+            command
+                .name(subcommandName)
+                .option("-s, --source <source id>")
+                .option("-r, --requestHandler <request handler id>")
+                .option("-p, --plugins <comma separated list of filepaths to plugins>")
+                .action((_options) => {
+                options = _options;
+            });
+            silenceCommand(command);
+            program.addCommand(command);
+            return command;
+        }
+        addSubcommand(program, "run");
+        addSubcommand(program, "show-schema");
+        addSubcommand(program, "web-ui");
+        try {
+            program.parse();
+        }
+        catch (error) {
+            // We don't care if there's an error
+        }
+        const sourceId = options.source;
+        const requestHandlerId = options.requestHandler;
+        const pluginFilePaths = typeof options.plugins === "string" ? options.plugins.split(",") : [];
+        const plugins = await Promise.all(pluginFilePaths
+            .filter((path) => path)
+            .map(async (pluginFilePath) => await tsImport(pluginFilePath, import.meta.url))).then((modules) => modules.map((module) => module.default));
+        const mediaFinder = new Liase({ plugins });
+        const source = mediaFinder.sources.find((source) => source.id === sourceId);
+        if (sourceId && !source) {
+            throw Error(`Could not find source for "${sourceId}"`);
+        }
+        const requestHandler = source?.requestHandlers.find((handler) => handler.id === requestHandlerId);
+        if (source && requestHandlerId && !requestHandler) {
+            throw Error(`Could not find request handler for "${requestHandlerId}"`);
+        }
+        cachedLiaseDetails = { source, requestHandler, plugins };
+    }
+    return cachedLiaseDetails;
+}
+export function getSharedLiaseOptions({ source, plugins }) {
+    const sourceOption = new Option("-s, --source <source id>", "Media finder source ID").makeOptionMandatory(true);
+    const requestHandlerOption = new Option("-r, --requestHandler <request handler id>", "ID of the request handler").makeOptionMandatory(true);
+    const pluginsOption = new Option("-p, --plugins <comma separated list of filepaths to plugins>", "Plugins to load");
+    const secretsSetOption = new Option("--secretsSet <secrets set name>", "Finds secrets set with given name and uses secrets in query");
+    const cacheNetworkRequestsOption = new Option("--cacheNetworkRequests <caching option>", `"never" will never cache network requests, "auto" will cache requests that seem like they might be cacheable and store them for as long as they seem fresh, ` +
+        `"always" will always cache requests with no expiry.`)
+        .choices(["never", "auto", "always"])
+        .default("always");
+    const mediaFinder = new Liase({ plugins });
+    sourceOption.choices(mediaFinder.sources.map((source) => source.id));
+    if (source) {
+        requestHandlerOption.choices(source.requestHandlers.map((handler) => handler.id));
+    }
+    return {
+        sourceOption,
+        requestHandlerOption,
+        pluginsOption,
+        cacheNetworkRequestsOption,
+        secretsSetOption,
+    };
+}
+export function getRequestFromArgs(options, requestHandler) {
+    const request = {};
+    if (requestHandler) {
+        for (const key in requestHandler.requestSchema.shape) {
+            request[key] = options[key];
+        }
+    }
+    request.queryType = options.requestHandler;
+    return request;
+}

package/dist/lib/liase-query.d.ts

@@ -0,0 +1,8 @@
+import { type LiaseQuery } from "@liase/core";
+export declare function getLiaseQuery({ request, secretsSet, cacheNetworkRequests, loadPluginsFromArgs, }: {
+    request: Record<string, unknown>;
+    secretsSet?: string;
+    cacheNetworkRequests?: "never" | "auto" | "always";
+    loadPluginsFromArgs?: boolean;
+}): Promise<LiaseQuery>;
+//# sourceMappingURL=liase-query.d.ts.map

package/dist/lib/liase-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liase-query.d.ts","sourceRoot":"","sources":["../../src/lib/liase-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EAGhB,MAAM,aAAa,CAAC;AAIrB,wBAAsB,aAAa,CAAC,EAClC,OAAO,EACP,UAAU,EACV,oBAAoB,EACpB,mBAAmB,GACpB,EAAE;IACD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oBAAoB,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACnD,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,GAAG,OAAO,CAAC,UAAU,CAAC,CAsBtB"}

package/dist/lib/liase-query.js

@@ -0,0 +1,25 @@
+import { createLiaseQuery, } from "@liase/core";
+import { getLiaseDetailsFromArgs } from "./liase-details.js";
+import { getSecretsSets } from "./secrets.js";
+export async function getLiaseQuery({ request, secretsSet, cacheNetworkRequests, loadPluginsFromArgs, }) {
+    const plugins = [];
+    if (loadPluginsFromArgs) {
+        const liaseDetails = await getLiaseDetailsFromArgs();
+        plugins.push(...liaseDetails.plugins);
+    }
+    let secrets = {};
+    if (secretsSet) {
+        const secretsSets = await getSecretsSets();
+        secrets = secretsSets[secretsSet];
+    }
+    return createLiaseQuery({
+        request: request,
+        queryOptions: {
+            secrets,
+            cacheNetworkRequests,
+        },
+        finderOptions: {
+            plugins,
+        },
+    });
+}

package/dist/lib/proxy.d.ts

@@ -0,0 +1,6 @@
+import { type Server } from "node:http";
+export declare function startProxyServer(): Promise<{
+    origin: string;
+    server: Server;
+}>;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/lib/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/lib/proxy.ts"],"names":[],"mappings":"AAAA,OAAa,EAAE,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAG9C,wBAAgB,gBAAgB,IAAI,OAAO,CAAC;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,CAiDD"}

package/dist/lib/proxy.js

@@ -0,0 +1,48 @@
+import http from "node:http";
+import { ProxyServer } from "@refactorjs/http-proxy";
+export function startProxyServer() {
+    const proxy = new ProxyServer();
+    proxy.on("proxyRes", (proxyRes, req, res) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        proxyRes.pipe(res);
+    });
+    const server = http.createServer((req, res) => {
+        const targetUrlString = req.url?.replace(/^\//, "") || "";
+        let targetUrl;
+        try {
+            targetUrl = new URL(targetUrlString);
+        }
+        catch (error) {
+            res.statusCode = 400;
+            res.end(`Invalid url "${targetUrlString}"`);
+            return;
+        }
+        req.url = targetUrl.pathname + targetUrl.search;
+        proxy.web(req, res, {
+            target: targetUrl.origin,
+            changeOrigin: true,
+            secure: false,
+            selfHandleResponse: true,
+        });
+    });
+    process.on("SIGINT", () => {
+        server.close();
+    });
+    return new Promise((resolve, reject) => {
+        server.on("error", reject);
+        server.on("listening", () => {
+            const address = server.address();
+            if (address === null) {
+                throw Error("Could not create proxy server");
+            }
+            const formattedAddress = typeof address === "object"
+                ? `http://localhost:${address.port}`
+                : address;
+            resolve({
+                server,
+                origin: formattedAddress,
+            });
+        });
+        server.listen();
+    });
+}

package/dist/lib/secrets.d.ts

@@ -0,0 +1,2 @@
+export declare function getSecretsSets(): Promise<Record<string, Record<string, unknown>>>;
+//# sourceMappingURL=secrets.d.ts.map

package/dist/lib/secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.d.ts","sourceRoot":"","sources":["../../src/lib/secrets.ts"],"names":[],"mappings":"AAKA,wBAAsB,cAAc,qDA+BnC"}

package/dist/lib/secrets.js

@@ -0,0 +1,30 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+let cachedSecretSets;
+export async function getSecretsSets() {
+    const defaultSecretSetsConfigPath = "./.secrets-sets.json";
+    const customSecretSetsConfigPath = process.env.SECRETS_SETS_CONFIG_PATH
+        ? path.resolve(process.env.SECRETS_SETS_CONFIG_PATH)
+        : "";
+    const secretSetsConfigPath = customSecretSetsConfigPath ?? defaultSecretSetsConfigPath;
+    if (!cachedSecretSets) {
+        let configString;
+        try {
+            configString = await fs.readFile(secretSetsConfigPath, "utf8");
+        }
+        catch (error) {
+            if (customSecretSetsConfigPath) {
+                console.warn(`Secrets sets config path set to ${secretSetsConfigPath} but file not found or accessible.`);
+            }
+            configString = "{}";
+        }
+        try {
+            cachedSecretSets = JSON.parse(configString);
+        }
+        catch (error) {
+            console.warn(`Secrets sets config path set to ${secretSetsConfigPath} but file is not valid JSON.`);
+            cachedSecretSets = {};
+        }
+    }
+    return cachedSecretSets;
+}

package/dist/lib/zod.d.ts

@@ -0,0 +1,50 @@
+import { type Primitive, type ZodFirstPartySchemaTypes, type z } from "zod";
+type SimpleSchema = ({
+    type: "string";
+    default?: string;
+    checks?: z.ZodStringCheck[];
+} | {
+    type: "number";
+    default?: number;
+    checks?: Array<z.ZodNumberCheck | z.ZodBigIntCheck>;
+} | {
+    type: "boolean";
+    default?: boolean;
+} | {
+    type: "date";
+    default?: Date | string;
+    checks?: z.ZodDateCheck[];
+} | {
+    type: "object";
+    children: {
+        [key: string]: SimpleSchema;
+    };
+    default?: {
+        [key: string]: unknown;
+    };
+} | {
+    type: "array";
+    children: SimpleSchema;
+    default?: unknown[];
+} | {
+    type: SimpleSchema[];
+    default?: unknown;
+} | {
+    type: "literal";
+    value: Primitive;
+    valueType: "string" | "number" | "boolean" | "null" | "other";
+    default?: never;
+} | {
+    type: "null";
+    default?: null;
+} | {
+    type: "other" | "undefined";
+    default?: unknown;
+    zodTypeName: ZodFirstPartySchemaTypes["_def"]["typeName"];
+}) & {
+    optional?: boolean;
+    description?: string;
+};
+export declare function zodSchemaToSimpleSchema(zodSchema: ZodFirstPartySchemaTypes): SimpleSchema;
+export {};
+//# sourceMappingURL=zod.d.ts.map

package/dist/lib/zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../src/lib/zod.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,wBAAwB,EAE7B,KAAK,CAAC,EACP,MAAM,KAAK,CAAC;AAEb,KAAK,YAAY,GAAG,CAChB;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,CAAC,CAAC,cAAc,EAAE,CAAC;CAC7B,GACD;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,cAAc,GAAG,CAAC,CAAC,cAAc,CAAC,CAAC;CACrD,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,CAAC,YAAY,EAAE,CAAC;CAC3B,GACD;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;KAAE,CAAC;IAC1C,OAAO,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;CACtC,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;CACrB,GACD;IACE,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC;IACjB,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;IAC9D,OAAO,CAAC,EAAE,KAAK,CAAC;CACjB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB,GACD;IACE,IAAI,EAAE,OAAO,GAAG,WAAW,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAC;CAC3D,CACJ,GAAG;IACF,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAuEF,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,wBAAwB,GAClC,YAAY,CAyLd"}

package/dist/lib/zod.js

@@ -0,0 +1,196 @@
+import { ZodFirstPartyTypeKind, } from "zod";
+function isZodType(zodSchema, type) {
+    return zodSchema?.constructor?.name === type;
+}
+export function zodSchemaToSimpleSchema(zodSchema) {
+    let simpleSchema;
+    const zodTypeName = zodSchema._def.typeName;
+    const description = zodSchema._def.description;
+    const defaultProps = {
+        ...(description ? { description } : {}),
+    };
+    // We don't use instanceof to match against an imported Zod class because the zod schema may be created
+    // with a different version of the Zod library and thus not be matched with instanceof
+    if (isZodType(zodSchema, "ZodObject")) {
+        simpleSchema = {
+            ...defaultProps,
+            type: "object",
+            children: {},
+        };
+        for (const [name, zodType] of Object.entries(zodSchema._def.shape())) {
+            simpleSchema.children[name] = zodSchemaToSimpleSchema(zodType);
+        }
+    }
+    else if (isZodType(zodSchema, "ZodIntersection")) {
+        const left = zodSchemaToSimpleSchema(zodSchema._def.left);
+        const right = zodSchemaToSimpleSchema(zodSchema._def.right);
+        simpleSchema = {
+            ...defaultProps,
+            type: "object",
+            children: { ...left.children, ...right.children },
+        };
+    }
+    else if (isZodType(zodSchema, "ZodArray")) {
+        simpleSchema = {
+            ...defaultProps,
+            type: "array",
+            children: zodSchemaToSimpleSchema(zodSchema._def.type),
+        };
+    }
+    else if (isZodType(zodSchema, "ZodSet")) {
+        simpleSchema = {
+            ...defaultProps,
+            type: "array",
+            children: zodSchemaToSimpleSchema(zodSchema._def.valueType),
+        };
+    }
+    else if (isZodType(zodSchema, "ZodUnion") ||
+        isZodType(zodSchema, "ZodDiscriminatedUnion")) {
+        const zodTypesInUnion = zodSchema._def.options;
+        const simpleSchemaTypesInUnion = zodTypesInUnion.map(zodSchemaToSimpleSchema);
+        simpleSchema = { ...defaultProps, type: simpleSchemaTypesInUnion };
+        const unionIncludesUndefined = simpleSchemaTypesInUnion.some((schema) => schema.type === "other" && schema.zodTypeName === "ZodUndefined");
+        if (unionIncludesUndefined) {
+            simpleSchema.optional = true;
+        }
+    }
+    else if (isZodType(zodSchema, "ZodOptional")) {
+        simpleSchema = {
+            ...defaultProps,
+            ...zodSchemaToSimpleSchema(zodSchema._def.innerType),
+            optional: true,
+        };
+    }
+    else if (isZodType(zodSchema, "ZodString")) {
+        simpleSchema = { ...defaultProps, type: "string" };
+        if (zodSchema._def.checks.length)
+            simpleSchema.checks = zodSchema._def.checks;
+    }
+    else if (isZodType(zodSchema, "ZodNumber") ||
+        isZodType(zodSchema, "ZodBigInt")) {
+        simpleSchema = { ...defaultProps, type: "number" };
+        if (zodSchema._def.checks.length)
+            simpleSchema.checks = zodSchema._def.checks;
+    }
+    else if (isZodType(zodSchema, "ZodBoolean")) {
+        simpleSchema = { ...defaultProps, type: "boolean" };
+    }
+    else if (isZodType(zodSchema, "ZodDate")) {
+        simpleSchema = { ...defaultProps, type: "date" };
+        if (zodSchema._def.checks.length)
+            simpleSchema.checks = zodSchema._def.checks;
+    }
+    else if (isZodType(zodSchema, "ZodNull")) {
+        simpleSchema = { ...defaultProps, type: "null" };
+    }
+    else if (isZodType(zodSchema, "ZodLiteral")) {
+        const value = zodSchema._def.value;
+        let valueType;
+        if (typeof value === "string") {
+            valueType = "string";
+        }
+        else if (typeof value === "number" || typeof value === "bigint") {
+            valueType = "number";
+        }
+        else if (typeof value === "boolean") {
+            valueType = "boolean";
+        }
+        else if (value === null) {
+            valueType = "null";
+        }
+        else {
+            valueType = "other";
+        }
+        simpleSchema = {
+            ...defaultProps,
+            type: "literal",
+            value,
+            valueType,
+        };
+    }
+    else if (isZodType(zodSchema, "ZodEnum")) {
+        const enumValues = zodSchema._def.values;
+        simpleSchema = {
+            ...defaultProps,
+            type: enumValues.map((enumValue) => ({
+                type: "literal",
+                value: enumValue,
+                valueType: "string",
+                zodTypeName: ZodFirstPartyTypeKind.ZodLiteral,
+            })),
+        };
+    }
+    else if (isZodType(zodSchema, "ZodEffects")) {
+        simpleSchema = {
+            ...defaultProps,
+            ...zodSchemaToSimpleSchema(zodSchema._def.schema),
+        };
+    }
+    else if (isZodType(zodSchema, "ZodNativeEnum")) {
+        simpleSchema = { ...defaultProps, type: "number" };
+    }
+    else if (isZodType(zodSchema, "ZodNullable")) {
+        simpleSchema = {
+            ...defaultProps,
+            type: [
+                zodSchemaToSimpleSchema(zodSchema._def.innerType),
+                { type: "null" },
+            ],
+        };
+    }
+    else if (isZodType(zodSchema, "ZodDefault")) {
+        simpleSchema = {
+            ...defaultProps,
+            ...zodSchemaToSimpleSchema(zodSchema._def.innerType),
+            default: zodSchema._def.defaultValue(),
+        };
+    }
+    else if (isZodType(zodSchema, "ZodCatch")) {
+        simpleSchema = {
+            ...defaultProps,
+            ...zodSchemaToSimpleSchema(zodSchema._def.innerType),
+        };
+    }
+    else if (isZodType(zodSchema, "ZodBranded")) {
+        simpleSchema = {
+            ...defaultProps,
+            ...zodSchemaToSimpleSchema(zodSchema._def.type),
+        };
+    }
+    else if (isZodType(zodSchema, "ZodPipeline")) {
+        simpleSchema = {
+            ...defaultProps,
+            ...zodSchemaToSimpleSchema(zodSchema._def.in),
+        };
+    }
+    else if (isZodType(zodSchema, "ZodAny") ||
+        isZodType(zodSchema, "ZodUndefined") ||
+        isZodType(zodSchema, "ZodNaN") ||
+        isZodType(zodSchema, "ZodUnknown") ||
+        isZodType(zodSchema, "ZodNever") ||
+        isZodType(zodSchema, "ZodVoid") ||
+        isZodType(zodSchema, "ZodTuple") ||
+        isZodType(zodSchema, "ZodRecord") ||
+        isZodType(zodSchema, "ZodMap") ||
+        isZodType(zodSchema, "ZodFunction") ||
+        isZodType(zodSchema, "ZodLazy") ||
+        isZodType(zodSchema, "ZodVoid") ||
+        isZodType(zodSchema, "ZodPromise") ||
+        isZodType(zodSchema, "ZodReadonly") ||
+        isZodType(zodSchema, "ZodSymbol")) {
+        simpleSchema = {
+            ...defaultProps,
+            type: "other",
+            zodTypeName,
+        };
+    }
+    else {
+        zodSchema; // Ensure we have a case for every type in ZodFirstPartySchemaTypes
+        simpleSchema = {
+            ...defaultProps,
+            type: "other",
+            zodTypeName,
+        };
+    }
+    return simpleSchema;
+}

package/dist/subcommands/run.d.ts

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

package/dist/subcommands/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/subcommands/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAW5C,wBAAsB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CA+ItD"}