@reliverse/dler 1.7.119 → 1.7.121

package/bin/impl/add/add-global/install-impl.d.ts

@@ -0,0 +1,38 @@
+/**
+ * # Single command
+ * rse invoke --command ai --args --agent relinter --target ./src
+ *
+ * # Chain execution
+ * rse invoke --chain setup-auth
+ *
+ * # Interactive mode
+ * rse invoke --interactive
+ *
+ * # Dry run
+ * rse invoke --chain new-project --dryRun
+ *
+ * # Help
+ * rse invoke
+ */
+interface InvokeOptions {
+    command: string;
+    args?: string[];
+    allowDangerous?: boolean;
+    dryRun?: boolean;
+    verbose?: boolean;
+}
+export declare function invokeSingleCommand(options: InvokeOptions, isDev: boolean): Promise<void>;
+export declare function executeChain(chainName: string, options: {
+    dryRun: boolean;
+    allowDangerous: boolean;
+    verbose: boolean;
+    isDev: boolean;
+}): Promise<void>;
+export declare function globalInstallInteractiveMode(options: {
+    allowDangerous: boolean;
+    dryRun: boolean;
+    verbose: boolean;
+    isDev: boolean;
+}): Promise<void>;
+export declare function showInvokeHelp(): Promise<void>;
+export {};

package/bin/impl/add/add-global/install-impl.js

@@ -0,0 +1,254 @@
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt, inputPrompt, selectPrompt } from "@reliverse/rempts";
+import { execaCommand } from "execa";
+const DANGEROUS_COMMANDS = ["login", "logout", "memory", "schema", "studio", "update", "upload"];
+const SAFE_COMMANDS = [
+  "add",
+  "ai",
+  "better/auth",
+  "clone",
+  "cmod",
+  "env",
+  "help",
+  "init",
+  "toolbox",
+  "mrse"
+];
+const PREDEFINED_CHAINS = {
+  "setup-auth": {
+    name: "Setup Authentication",
+    description: "Initialize a complete auth setup with Better Auth",
+    steps: [
+      { command: "better", args: ["auth", "init"] },
+      { command: "better", args: ["auth", "generate"] },
+      { command: "env" }
+    ]
+  },
+  "new-project": {
+    name: "New Project Setup",
+    description: "Create and setup a new project with dependencies",
+    steps: [{ command: "init" }, { command: "add" }, { command: "env" }]
+  },
+  "code-quality": {
+    name: "Code Quality Check",
+    description: "Run linting and code improvements",
+    steps: [{ command: "ai", args: ["--agent", "relinter"] }, { command: "cmod" }]
+  }
+};
+export async function invokeSingleCommand(options, isDev) {
+  const { command, args = [], allowDangerous, dryRun, verbose } = options;
+  if (DANGEROUS_COMMANDS.includes(command) && !allowDangerous) {
+    relinka("error", `Command '${command}' is restricted. Use --allowDangerous to override.`);
+    return;
+  }
+  const fullCommand = isDev ? `bun dev:${command}` : `rse ${command}`;
+  const fullArgs = args.length > 0 ? ` ${args.join(" ")}` : "";
+  const execCommand = `${fullCommand}${fullArgs}`;
+  if (verbose || dryRun) {
+    relinka("info", `${dryRun ? "[DRY RUN] " : ""}Executing: ${execCommand}`);
+  }
+  if (dryRun) {
+    return;
+  }
+  try {
+    await execaCommand(execCommand, { stdio: "inherit" });
+    if (verbose) {
+      relinka("success", `Command '${command}' completed successfully`);
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to execute '${command}': ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+export async function executeChain(chainName, options) {
+  const chain = PREDEFINED_CHAINS[chainName];
+  if (!chain) {
+    relinka(
+      "error",
+      `Unknown chain '${chainName}'. Available chains: ${Object.keys(PREDEFINED_CHAINS).join(", ")}`
+    );
+    return;
+  }
+  relinka("info", `Executing chain: ${chain.name}`);
+  if (chain.description) {
+    relinka("info", chain.description);
+  }
+  if (options.dryRun) {
+    relinka("info", "[DRY RUN] Chain steps:");
+    for (const step of chain.steps) {
+      const cmd = options.isDev ? `bun dev:${step.command}` : `rse ${step.command}`;
+      const args = step.args ? ` ${step.args.join(" ")}` : "";
+      relinka("info", `  ${cmd}${args}`);
+    }
+    return;
+  }
+  for (let i = 0; i < chain.steps.length; i++) {
+    const step = chain.steps[i];
+    if (!step) continue;
+    relinka("info", `Step ${i + 1}/${chain.steps.length}: ${step.command}`);
+    try {
+      await invokeSingleCommand(
+        {
+          command: step.command,
+          args: step.args,
+          allowDangerous: options.allowDangerous,
+          dryRun: false,
+          verbose: options.verbose
+        },
+        options.isDev
+      );
+    } catch (error) {
+      relinka(
+        "error",
+        `Chain failed at step ${i + 1}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      const shouldContinue = await confirmPrompt({
+        title: "Continue with remaining steps?",
+        defaultValue: false
+      });
+      if (!shouldContinue) {
+        process.exit(1);
+      }
+    }
+  }
+  relinka("success", `Chain '${chainName}' completed`);
+}
+export async function globalInstallInteractiveMode(options) {
+  const mode = await selectPrompt({
+    title: "RSE Invoke - Interactive Mode",
+    options: [
+      { label: "Execute single command", value: "single" },
+      { label: "Execute predefined chain", value: "chain" },
+      { label: "Create custom chain", value: "custom" },
+      { label: "Show available commands", value: "help" },
+      { label: "Exit", value: "exit" }
+    ]
+  });
+  switch (mode) {
+    case "single":
+      await interactiveSingleCommand(options);
+      break;
+    case "chain":
+      await interactiveChainSelection(options);
+      break;
+    case "custom":
+      await interactiveCustomChain(options);
+      break;
+    case "help":
+      await showInvokeHelp();
+      break;
+    case "exit":
+      process.exit(0);
+  }
+}
+async function interactiveSingleCommand(options) {
+  const availableCommands = options.allowDangerous ? [...SAFE_COMMANDS, ...DANGEROUS_COMMANDS] : SAFE_COMMANDS;
+  const command = await selectPrompt({
+    title: "Select command to invoke",
+    options: availableCommands.map((cmd) => ({ label: cmd, value: cmd }))
+  });
+  const argsInput = await inputPrompt({
+    title: "Command arguments (optional)",
+    content: "Enter space-separated arguments, or press Enter for none"
+  });
+  const args = argsInput.trim() ? argsInput.split(/\s+/) : [];
+  await invokeSingleCommand(
+    {
+      command,
+      args,
+      allowDangerous: options.allowDangerous,
+      dryRun: options.dryRun,
+      verbose: options.verbose
+    },
+    options.isDev
+  );
+}
+async function interactiveChainSelection(options) {
+  const chainOptions = Object.entries(PREDEFINED_CHAINS).map(([key, chain]) => ({
+    label: `${chain.name} - ${chain.description || "No description"}`,
+    value: key
+  }));
+  const selectedChain = await selectPrompt({
+    title: "Select predefined chain",
+    options: chainOptions
+  });
+  await executeChain(selectedChain, options);
+}
+async function interactiveCustomChain(options) {
+  relinka("info", "Custom chain creation");
+  const steps = [];
+  while (true) {
+    const shouldAddStep = await confirmPrompt({
+      title: steps.length === 0 ? "Add first command to chain?" : "Add another command to chain?",
+      defaultValue: true
+    });
+    if (!shouldAddStep) {
+      break;
+    }
+    const availableCommands = options.allowDangerous ? [...SAFE_COMMANDS, ...DANGEROUS_COMMANDS] : SAFE_COMMANDS;
+    const command = await selectPrompt({
+      title: `Select command ${steps.length + 1}`,
+      options: availableCommands.map((cmd) => ({ label: cmd, value: cmd }))
+    });
+    const argsInput = await inputPrompt({
+      title: "Command arguments (optional)",
+      content: "Enter space-separated arguments, or press Enter for none"
+    });
+    const args = argsInput.trim() ? argsInput.split(/\s+/) : [];
+    steps.push({ command, args });
+  }
+  if (steps.length === 0) {
+    relinka("info", "No commands added to chain");
+    return;
+  }
+  relinka("info", "Executing custom chain...");
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    if (!step) continue;
+    relinka("info", `Step ${i + 1}/${steps.length}: ${step.command}`);
+    try {
+      await invokeSingleCommand(step, options.isDev);
+    } catch (error) {
+      relinka(
+        "error",
+        `Custom chain failed at step ${i + 1}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      const shouldContinue = await confirmPrompt({
+        title: "Continue with remaining steps?",
+        defaultValue: false
+      });
+      if (!shouldContinue) {
+        break;
+      }
+    }
+  }
+  relinka("success", "Custom chain completed");
+}
+export async function showInvokeHelp() {
+  relinka("info", "RSE Invoke - Command Automation System");
+  relinka("info", "");
+  relinka("info", "Usage:");
+  relinka("info", "  rse invoke --command <cmd> [--args arg1 arg2...]");
+  relinka("info", "  rse invoke --chain <chain-name>");
+  relinka("info", "  rse invoke --interactive");
+  relinka("info", "");
+  relinka("info", "Examples:");
+  relinka("info", "  rse invoke --command add");
+  relinka("info", "  rse invoke --command ai --args --agent relinter --target ./src");
+  relinka("info", "  rse invoke --chain setup-auth");
+  relinka("info", "  rse invoke --interactive");
+  relinka("info", "");
+  relinka("info", "Available predefined chains:");
+  for (const [key, chain] of Object.entries(PREDEFINED_CHAINS)) {
+    relinka("info", `  ${key}: ${chain.description || chain.name}`);
+  }
+  relinka("info", "");
+  relinka("info", "Safe commands:", SAFE_COMMANDS.join(", "));
+  relinka("info", "Restricted commands (need --allowDangerous):", DANGEROUS_COMMANDS.join(", "));
+  relinka("info", "");
+  relinka("info", "Security:");
+  relinka("info", "  Enable self-invocation in reliverse.ts: allowSelfInvocation: true");
+  relinka("info", "  Use --allowDangerous flag for restricted commands");
+  relinka("info", "  Use --dryRun to preview commands without execution");
+}

package/bin/{app/better/auth/(generators) → impl/auth/generators}/auth-config.d.ts

@@ -1,17 +1,5 @@
 import { type spinner as clackSpinner } from "@reliverse/rempts";
-import type { SupportedDatabases, SupportedPlugin } from "../init/cmd.js";
-export interface Import {
-    path: string;
-    variables: {
-        asType?: boolean;
-        name: string;
-        as?: string;
-    }[] | {
-        asType?: boolean;
-        name: string;
-        as?: string;
-    };
-}
+import type { SupportedDatabases, SupportedPlugin } from "../impl/init";
 type Format = (code: string) => Promise<string>;
 interface CommonIndexConfig_Regex<AdditionalFields> {
     type: "regex";

package/bin/{app/better/auth/init/cmd.d.ts → impl/auth/impl/init.d.ts}

@@ -1,7 +1,9 @@
+import { z } from "zod";
+import type { AuthConfigImport } from "./types";
 /**
  * Should only use any database that is core DBs, and supports the Better Auth CLI generate functionality.
  */
-declare const supportedDatabases: readonly ["sqlite", "mysql", "mssql", "postgres", "drizzle:pg", "drizzle:mysql", "drizzle:sqlite", "prisma:postgresql", "prisma:mysql", "prisma:sqlite", "mongodb"];
+export declare const supportedDatabases: readonly ["sqlite", "mysql", "mssql", "postgres", "drizzle:pg", "drizzle:mysql", "drizzle:sqlite", "prisma:postgresql", "prisma:mysql", "prisma:sqlite", "mongodb"];
 export type SupportedDatabases = (typeof supportedDatabases)[number];
 export declare const supportedPlugins: readonly [{
     readonly id: "two-factor";
@@ -125,36 +127,57 @@ export declare const supportedPlugins: readonly [{
     readonly path: "better-auth/next-js";
 }];
 export type SupportedPlugin = (typeof supportedPlugins)[number];
-export declare const init: import("@reliverse/rempts").Command<{
-    cwd: {
-        type: "string";
-        description: string;
-        default: string;
-    };
-    config: {
-        type: "string";
-        description: string;
-        optional: boolean;
-    };
-    tsconfig: {
-        type: "string";
-        description: string;
-        optional: boolean;
-    };
-    "skip-db": {
-        type: "boolean";
-        description: string;
-        optional: boolean;
-    };
-    "skip-plugins": {
-        type: "boolean";
-        description: string;
-        optional: boolean;
-    };
-    "package-manager": {
-        type: "string";
-        description: string;
-        optional: boolean;
-    };
-}>;
-export {};
+export declare function formatWithBiome(code: string, _filepath: string): Promise<string>;
+export declare const getDefaultAuthConfig: ({ appName }: {
+    appName?: string;
+}) => Promise<string>;
+export type SupportedFrameworks = "vanilla" | "react" | "vue" | "svelte" | "solid" | "nextjs";
+export declare const getDefaultAuthClientConfig: ({ auth_config_path, framework, clientPlugins, }: {
+    framework: SupportedFrameworks;
+    auth_config_path: string;
+    clientPlugins: {
+        id: string;
+        name: string;
+        contents: string;
+        imports: AuthConfigImport[];
+    }[];
+}) => Promise<string>;
+export declare const optionsSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    config: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodEnum<{
+        mysql: "mysql";
+        sqlite: "sqlite";
+        mongodb: "mongodb";
+        postgres: "postgres";
+        mssql: "mssql";
+        "drizzle:pg": "drizzle:pg";
+        "drizzle:mysql": "drizzle:mysql";
+        "drizzle:sqlite": "drizzle:sqlite";
+        "prisma:postgresql": "prisma:postgresql";
+        "prisma:mysql": "prisma:mysql";
+        "prisma:sqlite": "prisma:sqlite";
+    }>>;
+    "skip-db": z.ZodOptional<z.ZodBoolean>;
+    "skip-plugins": z.ZodOptional<z.ZodBoolean>;
+    "package-manager": z.ZodOptional<z.ZodString>;
+    tsconfig: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const outroText = "\uD83E\uDD73 All Done, Happy Hacking!";
+export declare function getLatestNpmVersion(packageName: string): Promise<string>;
+export declare function getPackageManager(): Promise<"bun" | "npm" | "pnpm" | "yarn">;
+export declare function getEnvFiles(cwd: string): Promise<string[]>;
+export declare function updateEnvs({ envs, files, isCommented, }: {
+    /**
+     * The ENVs to append to the file
+     */
+    envs: string[];
+    /**
+     * Full file paths
+     */
+    files: string[];
+    /**
+     * Weather to comment the all of the envs or not
+     */
+    isCommented: boolean;
+}): Promise<void>;