@reliverse/rempts 1.7.29 → 1.7.30

package/bin/libs/launcher/trpc-orpc-support/prompts.js

@@ -0,0 +1,534 @@
+import { Argument, Command, Option } from "commander";
+const parseUpstreamOptionInfo = (value) => {
+  if (typeof value !== "string" || !value.startsWith("{")) return null;
+  try {
+    const info = JSON.parse(value);
+    if (info.typeName !== "UpstreamOptionInfo") return null;
+    return info;
+  } catch {
+    return null;
+  }
+};
+const parseUpstreamArgumentInfo = (value) => {
+  if (typeof value !== "string" || !value.startsWith("{")) return null;
+  try {
+    const info = JSON.parse(value);
+    if (info.typeName !== "UpstreamArgumentInfo") return null;
+    return info;
+  } catch {
+    return null;
+  }
+};
+const getDefaultSubcommand = (command) => {
+  const defaultChild = /Available subcommands:.* (\S+) \(default\)/.exec(
+    command.description()
+  )?.[1];
+  return defaultChild ? command.commands.find((c) => c.name() === defaultChild) : void 0;
+};
+export const createShadowCommand = (command, onAnalyze) => {
+  const shadow = new Command(command.name());
+  shadow.exitOverride();
+  shadow.configureOutput({
+    writeOut: () => {
+    },
+    writeErr: () => {
+    }
+  });
+  const argumentsMap = /* @__PURE__ */ new Map();
+  const optionsMap = /* @__PURE__ */ new Map();
+  command.options.forEach((original) => {
+    const id = Date.now().toString() + Math.random().toString().slice(1);
+    const shadowOption = new Option(
+      original.flags.replace("<", "[").replace(">", "]"),
+      JSON.stringify([`id=${id}`, original.description])
+    );
+    const upstreamOptionInfo = {
+      typeName: "UpstreamOptionInfo",
+      id,
+      specified: false
+    };
+    shadowOption.default(JSON.stringify(upstreamOptionInfo));
+    shadowOption.argParser(
+      (value) => JSON.stringify({ ...upstreamOptionInfo, specified: true, value })
+    );
+    shadow.addOption(shadowOption);
+    optionsMap.set(id, { shadow: shadowOption, original });
+  });
+  command.registeredArguments.forEach((original) => {
+    const shadowArgument = new Argument(original.name(), original.description);
+    const id = Date.now().toString() + Math.random().toString().slice(1);
+    shadowArgument.argOptional();
+    const upstreamArgumentInfo = {
+      typeName: "UpstreamArgumentInfo",
+      id,
+      specified: false
+    };
+    shadowArgument.default(JSON.stringify(upstreamArgumentInfo));
+    shadowArgument.argParser(
+      (value) => JSON.stringify({ ...upstreamArgumentInfo, specified: true, value })
+    );
+    shadow.addArgument(shadowArgument);
+    argumentsMap.set(id, { shadow: shadowArgument, original });
+  });
+  const analysis = {
+    command: { shadow, original: command },
+    arguments: [],
+    options: []
+  };
+  shadow.action(async (...args) => {
+    const positionalValues = args.slice(0, -2);
+    const options = shadow.opts();
+    if (args.at(-2) !== options) {
+      throw new Error(
+        "Unexpected args format, second last arg is not the options object",
+        { cause: args }
+      );
+    }
+    if (args.at(-1) !== shadow) {
+      throw new Error(
+        "Unexpected args format, last arg is not the Command instance",
+        { cause: args }
+      );
+    }
+    positionalValues.forEach((value) => {
+      const argumentInfo = parseUpstreamArgumentInfo(value);
+      if (argumentInfo) {
+        analysis.arguments.push({
+          ...argumentsMap.get(argumentInfo.id),
+          value: argumentInfo.value,
+          specified: argumentInfo.specified
+        });
+      }
+    });
+    Object.values(options).forEach((value) => {
+      const upstreamOptionInfo = parseUpstreamOptionInfo(value);
+      if (upstreamOptionInfo) {
+        analysis.options.push({
+          ...optionsMap.get(upstreamOptionInfo.id),
+          value: upstreamOptionInfo.value,
+          specified: upstreamOptionInfo.specified
+        });
+      }
+    });
+    await onAnalyze(analysis);
+  });
+  command.commands.forEach((subcommand) => {
+    const shadowSubcommand = createShadowCommand(subcommand, onAnalyze);
+    shadow.addCommand(shadowSubcommand);
+  });
+  return shadow;
+};
+const inquirerPrompter = (prompts) => {
+  return prompts;
+};
+const clackPrompter = (prompts) => {
+  const clack = prompts;
+  class ExitPromptError extends Error {
+  }
+  const throwOnCancel = (value) => {
+    if (clack.isCancel(value)) throw new ExitPromptError();
+    return value;
+  };
+  return {
+    input: async (params) => {
+      return clack.text({
+        message: params.message,
+        initialValue: params.default,
+        defaultValue: params.default,
+        placeholder: params.default,
+        validate: params.validate ? (input) => {
+          const result = params.validate(input);
+          if (result === true) return void 0;
+          if (result === false) return "Invalid input";
+          return result;
+        } : void 0
+      }).then(throwOnCancel);
+    },
+    checkbox: async (params) => {
+      return clack.multiselect({
+        message: params.message,
+        options: params.choices.map((c) => ({
+          label: c.name,
+          value: c.value
+        })),
+        initialValues: params.choices.flatMap(
+          (c) => c.checked ? [c.value] : []
+        )
+      }).then(throwOnCancel);
+    },
+    confirm: async (params) => {
+      return clack.confirm({
+        message: params.message,
+        initialValue: params.default
+      }).then(throwOnCancel);
+    },
+    select: async (params) => {
+      return clack.select({
+        message: params.message,
+        options: params.choices.map((sorc) => {
+          const c = typeof sorc === "string" ? { name: sorc, value: sorc } : sorc;
+          return {
+            label: c.name,
+            value: c.value,
+            hint: c.description
+          };
+        }),
+        initialValue: params.default
+      }).then(throwOnCancel);
+    }
+  };
+};
+const promptsPrompter = (prompts) => {
+  const p = prompts;
+  function x() {
+    return (value) => value.x;
+  }
+  return {
+    input: async (params) => {
+      return p({
+        name: "x",
+        type: "text",
+        message: params.message,
+        validate: params.validate,
+        initial: params.default
+      }).then(x());
+    },
+    confirm: async (params) => {
+      return p({
+        name: "x",
+        type: "confirm",
+        message: params.message,
+        active: params.default ? "yes" : "no"
+      }).then(x());
+    },
+    select: async (params) => {
+      const choicesObjects = params.choices.map(
+        (c) => typeof c === "string" ? { name: c, value: c } : c
+      );
+      return p({
+        name: "x",
+        type: "select",
+        message: params.message,
+        active: params.default,
+        choices: choicesObjects.map((c) => ({
+          title: c.name || c.value,
+          value: c.value
+        })),
+        initial: params.default ? choicesObjects.findIndex((c) => c.value === params.default) : void 0
+      }).then(x());
+    },
+    checkbox: async (params) => {
+      const choicesObjects = params.choices.map(
+        (c) => typeof c === "string" ? { name: c, value: c } : c
+      );
+      return p({
+        name: "x",
+        type: "multiselect",
+        message: params.message,
+        choices: choicesObjects.map((c) => ({
+          title: c.name || c.value,
+          value: c.value,
+          selected: c.checked
+        }))
+      }).then(x());
+    }
+  };
+};
+const enquirerPrompter = (prompts) => {
+  const enquirer = prompts;
+  function x() {
+    return (value) => value.x;
+  }
+  return {
+    input: async (params) => {
+      return enquirer.prompt({
+        type: "input",
+        name: "x",
+        message: params.message,
+        validate: params.validate,
+        initial: params.default
+      }).then(x());
+    },
+    confirm: async (params) => {
+      return enquirer.prompt({
+        type: "confirm",
+        name: "x",
+        message: params.message,
+        validate: params.validate,
+        initial: params.default
+      }).then(x());
+    },
+    select: async (params) => {
+      return enquirer.prompt({
+        type: "select",
+        name: "x",
+        message: params.message,
+        // @ts-expect-error not sure why this is an error, in the IDE it infers the type correctly
+        choices: params.choices.slice(),
+        validate: params.validate,
+        initial: params.default
+      }).then(x());
+    },
+    checkbox: async (params) => {
+      return enquirer.prompt({
+        type: "multiselect",
+        name: "x",
+        message: params.message,
+        // @ts-expect-error not sure why this is an error, in the IDE it infers the type correctly
+        choices: params.choices.slice().map((c) => ({
+          name: c.name,
+          value: c.value
+        })),
+        // validate: params.validate ? v => params.validate!([{value: v}]) : undefined,
+        initial: params.choices.flatMap((c, i) => c.checked ? [i] : [])
+      }).then(x());
+    }
+  };
+};
+export const promptify = (program, prompts) => {
+  let promptsInput = prompts;
+  if (promptsInput?.default) promptsInput = promptsInput.default;
+  let prompter;
+  if (typeof promptsInput === "function" && typeof promptsInput.inject === "function") {
+    prompter = promptsPrompter(promptsInput);
+  } else if (promptsInput?.name === "Enquirer") {
+    prompter = enquirerPrompter(promptsInput);
+  } else if (typeof promptsInput?.rawlist === "function") {
+    prompter = inquirerPrompter(promptsInput);
+  } else if (typeof promptsInput?.intro === "function") {
+    prompter = clackPrompter(promptsInput);
+  } else if (typeof promptsInput === "function") {
+    prompter = promptsInput(program);
+  } else {
+    prompter = promptsInput;
+  }
+  const command = program;
+  const analyseThenParse = async (argv, parseOptions) => {
+    if (parseOptions?.from === "electron") {
+      console.warn(
+        `Warning: using prompts in electron mode is untested. The first two args of $0 are not available in electron mode. Assuming that the first two args of ${JSON.stringify(argv)} are electron-related and not intended for the CLI.`
+      );
+    }
+    if (parseOptions?.from !== "user") {
+      argv = argv.slice(2);
+      parseOptions = { from: "user" };
+    }
+    const f = { command, args: [...argv] };
+    const nextArgv = [...f.args];
+    let analysis;
+    const maxAttempts = 100;
+    for (let i = maxAttempts; i >= 0 && !analysis; i--) {
+      analysis = await new Promise((resolve, reject) => {
+        const shadow = createShadowCommand(f.command, async (an) => {
+          if (an.command.original.commands.length === 0) {
+            resolve(an);
+            return;
+          }
+          const defaultSubcommand = getDefaultSubcommand(an.command.original);
+          if (defaultSubcommand) {
+            resolve(an);
+            return;
+          }
+          const name = await prompter.select(
+            {
+              message: `Select a ${an.command.original.name() || ""} subcommand`.replace(
+                "  ",
+                " "
+              ),
+              choices: an.command.original.commands.map((c) => ({
+                name: c.name(),
+                value: c.name(),
+                description: c.description()
+              }))
+            },
+            {}
+          );
+          nextArgv.push(name);
+          resolve(void 0);
+        });
+        shadow.parseAsync(nextArgv, parseOptions).catch((e) => {
+          if (e?.constructor?.name === "CommanderError") {
+            resolve({
+              command: { shadow: f.command, original: f.command },
+              arguments: [],
+              options: []
+            });
+          } else {
+            reject(e);
+          }
+        });
+      });
+    }
+    if (!analysis) {
+      const message = `Failed to find a subcommand after ${maxAttempts} attempts - failing to avoid an infinite loop. This is probably a bug in @reliverse/rempts.`;
+      throw new Error(message);
+    }
+    const getMessage = (argOrOpt) => {
+      const name = "long" in argOrOpt ? argOrOpt.flags : `[${argOrOpt.name()}]`;
+      const parts = [
+        name,
+        argOrOpt.description,
+        argOrOpt.defaultValue && `(default: ${argOrOpt.defaultValue})`,
+        !argOrOpt.defaultValue && !argOrOpt.required && "(optional)"
+      ];
+      return `${parts.filter(Boolean).join(" ").trim()}:`;
+    };
+    const baseContext = {
+      command: analysis.command.original,
+      inputs: {
+        argv,
+        arguments: analysis.arguments.map((a) => ({
+          name: a.original.name(),
+          specified: a.specified,
+          value: a.value
+        })),
+        options: analysis.options.map((o) => ({
+          name: o.original.name(),
+          specified: o.specified,
+          value: o.value
+        }))
+      }
+    };
+    await prompter.setup?.(baseContext);
+    const promptConfig = "necessary";
+    let shouldPrompt;
+    if (promptConfig === "always") {
+      shouldPrompt = true;
+    } else if (promptConfig === "never") {
+      shouldPrompt = false;
+    } else {
+      promptConfig;
+      const someRequiredArgsUnspecified = analysis.arguments.some(
+        (a) => a.original.required && !a.specified
+      );
+      const someRequiredOptionsUnspecified = analysis.options.some(
+        (o) => o.original.required && !o.specified
+      );
+      shouldPrompt = someRequiredArgsUnspecified || someRequiredOptionsUnspecified;
+    }
+    if (shouldPrompt) {
+      for (const arg of analysis.arguments) {
+        const ctx = { ...baseContext, argument: arg.original };
+        if (!arg.specified) {
+          const parseArg = "parseArg" in arg.original && typeof arg.original.parseArg === "function" ? arg.original.parseArg : void 0;
+          const promptedValue = await prompter.input(
+            {
+              message: getMessage(arg.original),
+              required: arg.original.required,
+              default: arg.value,
+              validate: (input) => {
+                try {
+                  parseArg?.(input);
+                  return true;
+                } catch (e) {
+                  return e?.message || e;
+                }
+              }
+            },
+            ctx
+          );
+          nextArgv.push(promptedValue);
+        }
+      }
+      for (const option of analysis.options) {
+        const ctx = { ...baseContext, option: option.original };
+        if (!option.specified) {
+          const fullFlag = option.original.long || `--${option.original.name()}`;
+          const isBoolean = option.original.isBoolean() || option.original.flags.includes("[boolean]");
+          if (isBoolean) {
+            const promptedValue = await prompter.confirm(
+              {
+                message: getMessage(option.original),
+                default: option.original.defaultValue ?? false
+              },
+              ctx
+            );
+            if (promptedValue) nextArgv.push(fullFlag);
+          } else if (option.original.variadic && option.original.argChoices) {
+            const choices = option.original.argChoices.slice();
+            const results = await prompter.checkbox(
+              {
+                message: getMessage(option.original),
+                choices: choices.map((choice) => ({
+                  value: choice,
+                  name: choice,
+                  checked: true
+                }))
+              },
+              ctx
+            );
+            results.forEach((result) => {
+              if (typeof result === "string") nextArgv.push(fullFlag, result);
+            });
+          } else if (option.original.argChoices) {
+            const choices = option.original.argChoices.slice();
+            const set = new Set(choices);
+            const promptedValue = await prompter.select(
+              {
+                message: getMessage(option.original),
+                choices,
+                default: option.original.defaultValue
+                // required: option.original.required,
+              },
+              ctx
+            );
+            if (set.has(promptedValue)) {
+              nextArgv.push(fullFlag, promptedValue);
+            }
+          } else if (option.original.variadic) {
+            const values = [];
+            do {
+              const promptedValue = await prompter.input(
+                {
+                  message: getMessage(option.original),
+                  default: option.original.defaultValue?.[values.length]
+                },
+                ctx
+              );
+              if (!promptedValue) break;
+              values.push(fullFlag, promptedValue);
+            } while (values);
+            nextArgv.push(...values);
+          } else {
+            const getParsedValue = (input) => {
+              return option.original.parseArg ? option.original.parseArg(
+                input,
+                void 0
+              ) : input;
+            };
+            const promptedValue = await prompter.input(
+              {
+                message: getMessage(option.original),
+                default: option.value,
+                required: option.original.required,
+                validate: (input) => {
+                  const parsed = getParsedValue(input);
+                  if (parsed == null && input != null) return "Invalid value";
+                  return true;
+                }
+              },
+              ctx
+            );
+            if (promptedValue)
+              nextArgv.push(
+                fullFlag,
+                getParsedValue(promptedValue) ?? promptedValue
+              );
+          }
+        }
+      }
+    }
+    await prompter.teardown?.(baseContext);
+    return f.command.parseAsync(nextArgv, parseOptions);
+  };
+  const parseAsync = (args, parseOptions) => analyseThenParse(args, parseOptions).catch((e) => {
+    if (e?.constructor?.name === "ExitPromptError") return;
+    throw e;
+  });
+  return new Proxy(program, {
+    get(target, prop, receiver) {
+      if (prop === "parseAsync") return parseAsync;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+};

package/bin/libs/launcher/trpc-orpc-support/standard-schema/contract.d.ts

@@ -0,0 +1,53 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1Props<Input, Output>;
+}
+/** The Standard Schema properties interface. */
+export interface StandardSchemaV1Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: StandardSchemaV1Types<Input, Output> | undefined;
+}
+/** The result interface of the validate function. */
+export type StandardSchemaV1Result<Output> = StandardSchemaV1SuccessResult<Output> | StandardSchemaV1FailureResult;
+/** The result interface if validation succeeds. */
+export interface StandardSchemaV1SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+}
+/** The result interface if validation fails. */
+export interface StandardSchemaV1FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: readonly StandardSchemaV1Issue[];
+}
+/** The issue interface of the failure output. */
+export interface StandardSchemaV1Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: readonly (PropertyKey | StandardSchemaV1PathSegment)[] | undefined;
+}
+/** The path segment interface of the issue. */
+export interface StandardSchemaV1PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+}
+/** The Standard Schema types interface. */
+export interface StandardSchemaV1Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+}
+/** Infers the input type of a Standard Schema. */
+export type StandardSchemaV1InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+/** Infers the output type of a Standard Schema. */
+export type StandardSchemaV1InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];

package/bin/libs/launcher/trpc-orpc-support/standard-schema/errors.d.ts

@@ -0,0 +1,9 @@
+import type { StandardSchemaV1FailureResult } from "./contract";
+export declare const prettifyStandardSchemaError: (error: unknown) => string | null;
+export declare function toDotPath(path: (string | number | symbol)[]): string;
+export declare class StandardSchemaV1Error extends Error implements StandardSchemaV1FailureResult {
+    issues: StandardSchemaV1FailureResult["issues"];
+    constructor(failure: StandardSchemaV1FailureResult, options?: {
+        cause?: Error;
+    });
+}

package/bin/libs/launcher/trpc-orpc-support/standard-schema/errors.js

@@ -0,0 +1,47 @@
+import { looksLikeStandardSchemaFailure } from "./utils.js";
+export const prettifyStandardSchemaError = (error) => {
+  if (!looksLikeStandardSchemaFailure(error)) return null;
+  const issues = [...error.issues].map((issue) => {
+    const path = issue.path || [];
+    const primitivePathSegments = path.map((segment) => {
+      if (typeof segment === "string" || typeof segment === "number" || typeof segment === "symbol")
+        return segment;
+      return segment.key;
+    });
+    const dotPath = toDotPath(primitivePathSegments);
+    return {
+      issue,
+      path,
+      primitivePathSegments,
+      dotPath
+    };
+  }).sort((a, b) => a.path.length - b.path.length);
+  const lines = [];
+  for (const { issue, dotPath } of issues) {
+    let message = `\u2716 ${issue.message}`;
+    if (dotPath) message += ` \u2192 at ${dotPath}`;
+    lines.push(message);
+  }
+  return lines.join("\n");
+};
+export function toDotPath(path) {
+  const segs = [];
+  for (const seg of path) {
+    if (typeof seg === "number") segs.push(`[${seg}]`);
+    else if (typeof seg === "symbol")
+      segs.push(`[${JSON.stringify(String(seg))}]`);
+    else if (/[^\w$]/.test(seg)) segs.push(`[${JSON.stringify(seg)}]`);
+    else {
+      if (segs.length) segs.push(".");
+      segs.push(seg);
+    }
+  }
+  return segs.join("");
+}
+export class StandardSchemaV1Error extends Error {
+  issues;
+  constructor(failure, options) {
+    super("Standard Schema error - details in `issues`.", options);
+    this.issues = failure.issues;
+  }
+}

package/bin/libs/launcher/trpc-orpc-support/standard-schema/utils.d.ts

@@ -0,0 +1,3 @@
+import type { StandardSchemaV1, StandardSchemaV1FailureResult } from "./contract";
+export declare const looksLikeStandardSchemaFailure: (error: unknown) => error is StandardSchemaV1FailureResult;
+export declare const looksLikeStandardSchema: (thing: unknown) => thing is StandardSchemaV1;

package/bin/libs/launcher/trpc-orpc-support/standard-schema/utils.js

@@ -0,0 +1,6 @@
+export const looksLikeStandardSchemaFailure = (error) => {
+  return !!error && typeof error === "object" && "issues" in error && Array.isArray(error.issues);
+};
+export const looksLikeStandardSchema = (thing) => {
+  return !!thing && typeof thing === "object" && "~standard" in thing && typeof thing["~standard"] === "object";
+};