@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/invoke/cmd.js

@@ -0,0 +1,353 @@
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt, defineCommand, inputPrompt, selectPrompt } from "@reliverse/rempts";
+import { execaCommand } from "execa";
+import { getOrCreateRseConfig } from "../config/cfg-core.js";
+import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
+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 default defineCommand({
+  meta: {
+    name: "invoke",
+    description: "Invoke RSE CLI commands programmatically for AI agents and automation"
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Run in development mode",
+      default: false
+    },
+    command: {
+      type: "string",
+      description: "RSE command to invoke (e.g., 'add', 'ai', 'init')",
+      required: false
+    },
+    args: {
+      type: "array",
+      description: "Arguments to pass to the invoked command",
+      required: false
+    },
+    chain: {
+      type: "string",
+      description: "Execute a predefined command chain",
+      required: false
+    },
+    dryRun: {
+      type: "boolean",
+      description: "Show what would be executed without running commands",
+      default: false
+    },
+    allowDangerous: {
+      type: "boolean",
+      description: "Allow execution of potentially dangerous commands",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Show detailed execution information",
+      default: false
+    },
+    interactive: {
+      type: "boolean",
+      description: "Use interactive mode for command selection",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const {
+      dev: isDev,
+      command,
+      args: cmdArgs,
+      chain,
+      dryRun,
+      allowDangerous,
+      verbose,
+      interactive
+    } = args;
+    const cwd = getCurrentWorkingDirectory();
+    const { config } = await getOrCreateRseConfig({
+      projectPath: cwd,
+      isDev,
+      overrides: {}
+    });
+    const allowSelfInvocation = config.customRules?.allowSelfInvocation === true;
+    if (!allowSelfInvocation && !isDev) {
+      relinka(
+        "error",
+        "Self-invocation is disabled. Enable it in reliverse.ts with 'customRules: { allowSelfInvocation: true }'"
+      );
+      process.exit(1);
+    }
+    try {
+      if (chain) {
+        await executeChain(chain, { dryRun, allowDangerous, verbose, isDev });
+      } else if (command) {
+        await invokeSingleCommand(
+          {
+            command,
+            args: cmdArgs || [],
+            allowDangerous,
+            dryRun,
+            verbose
+          },
+          isDev
+        );
+      } else if (interactive) {
+        await interactiveMode({ allowDangerous, dryRun, verbose, isDev });
+      } else {
+        await showInvokeHelp();
+      }
+    } catch (error) {
+      relinka("error", "Invoke failed:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+});
+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)}`
+    );
+  }
+}
+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`);
+}
+async function interactiveMode(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");
+}
+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/libs/cmd.js

@@ -50,7 +50,7 @@ export default defineCommand({
       relinka("error", "\u274C No library names provided");
       return;
     }
-    const dlerConfigPath = path.resolve(".config/dler.ts");
+    const dlerConfigPath = path.resolve("reliverse.ts");
     let dlerConfig;
     try {
       const jiti = createJiti(import.meta.url);
@@ -58,7 +58,7 @@ export default defineCommand({
         default: true
       });
     } catch {
-      relinka("error", "\u274C Failed to read .config/dler.ts");
+      relinka("error", "\u274C Failed to read reliverse.ts");
       return;
     }
     const { libsDirSrc, libsList } = dlerConfig;

package/bin/app/login/cmd.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    dev: {
+        type: "boolean";
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/login/cmd.js

@@ -0,0 +1,41 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import { useLocalhost } from "../config/constants.js";
+import { showAnykeyPrompt } from "../init/use-template/cp-modules/cli-main-modules/modules/showAnykeyPrompt.js";
+import { auth } from "./login-impl.js";
+import { getOrCreateReliverseMemory } from "../utils/reliverseMemory.js";
+export default defineCommand({
+  meta: {
+    name: "login",
+    description: "Authenticate your device",
+    hidden: true
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Run the CLI in dev mode"
+    }
+  },
+  run: async ({ args }) => {
+    const isDev = args.dev;
+    const memory = await getOrCreateReliverseMemory();
+    const isAuthenticated = memory.code && memory.key;
+    if (isAuthenticated) {
+      relinka("success", "You're already logged in.");
+      if (isDev) {
+        relinka("info", "Try `bun dev:logout` cmd.");
+      } else {
+        relinka("info", "Try `rse logout` cmd.");
+      }
+      process.exit(0);
+    }
+    await showAnykeyPrompt();
+    await auth({ isDev, useLocalhost });
+    if (isDev) {
+      relinka("success", "You can run `bun dev` now! Happy Reliversing! \u{1F389}");
+    } else {
+      relinka("success", "You can run `rse cli` now! Happy Reliversing! \u{1F389}");
+    }
+    process.exit(0);
+  }
+});

package/bin/app/login/login-impl.d.ts

@@ -0,0 +1,7 @@
+import "dotenv/config";
+import type { ReliverseMemory } from "../utils/schemaMemory.js";
+export declare function auth({ isDev, useLocalhost }: {
+    isDev: boolean;
+    useLocalhost: boolean;
+}): Promise<void>;
+export declare function authCheck(isDev: boolean, memory: ReliverseMemory, useLocalhost: boolean): Promise<void>;

package/bin/app/login/login-impl.js

@@ -0,0 +1,182 @@
+import { re } from "@reliverse/relico";
+import { relinka } from "@reliverse/relinka";
+import { useSpinner } from "@reliverse/rempts";
+import { listen } from "async-listen";
+import http from "http";
+import { customAlphabet } from "nanoid";
+import "dotenv/config";
+import { setTimeout } from "node:timers";
+import open from "open";
+import url from "url";
+import { cliDomainDocs, memoryPath } from "../config/constants.js";
+import { showAnykeyPrompt } from "../init/use-template/cp-modules/cli-main-modules/modules/showAnykeyPrompt.js";
+import { getOrCreateReliverseMemory, updateReliverseMemory } from "../utils/reliverseMemory.js";
+class UserCancellationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserCancellationError";
+  }
+}
+const nanoid = customAlphabet("123456789QAZWSXEDCRFVTGBYHNUJMIKOLP", 5);
+export async function auth({ isDev, useLocalhost }) {
+  relinka("info", "Let's authenticate you...");
+  const spinner = useSpinner({
+    text: "Waiting for user confirmation..."
+  }).start();
+  try {
+    const server = http.createServer();
+    let port;
+    try {
+      const serverListen = await listen(server, {
+        port: 0,
+        host: "localhost"
+      });
+      port = serverListen.port;
+      relinka("verbose", `Local server listening on http://localhost:${port}`);
+    } catch (listenError) {
+      relinka(
+        "error",
+        "Failed to start local server:",
+        listenError instanceof Error ? listenError.message : String(listenError)
+      );
+      throw listenError;
+    }
+    const authPromise = new Promise((resolve, reject) => {
+      server.on("request", (req, res) => {
+        relinka("verbose", `Received ${req.method} request on ${req.url}`);
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+        if (req.method === "OPTIONS") {
+          relinka("verbose", "Handling OPTIONS request");
+          res.writeHead(200);
+          res.end();
+        } else if (req.method === "GET") {
+          const parsedUrl = url.parse(req.url ?? "", true);
+          const queryParams = parsedUrl.query;
+          relinka("verbose", `Parsed query parameters: ${JSON.stringify(queryParams)}`);
+          if (queryParams.cancelled) {
+            relinka("verbose", "User cancelled the login process...");
+            relinka("verbose", "Sleep 2s to finish the fetch process...");
+            void new Promise((r) => setTimeout(r, 2e3)).then(() => {
+              res.writeHead(200);
+              res.end();
+              server.close();
+              reject(new UserCancellationError("Login process cancelled by user."));
+            });
+            return;
+          } else {
+            relinka("verbose", `Received authentication data: ${JSON.stringify(queryParams)}`);
+            res.writeHead(200);
+            res.end();
+            resolve(queryParams);
+          }
+        } else {
+          relinka("error", `Unhandled request method: ${req.method}`);
+          res.writeHead(405);
+          res.end();
+        }
+      });
+      server.on("error", (error) => {
+        relinka(
+          "error",
+          "Local server encountered an error:",
+          error instanceof Error ? error.message : String(error)
+        );
+        reject(error);
+      });
+    });
+    const redirect = `http://localhost:${port}`;
+    const code = nanoid();
+    const clientUrl = isDev ? useLocalhost ? "http://localhost:3000" : "https://reliverse.org" : "https://reliverse.org";
+    relinka("verbose", `Using client URL: ${clientUrl}`);
+    const confirmationUrl = new URL(`${clientUrl}/auth/confirm`);
+    confirmationUrl.searchParams.append("code", code);
+    confirmationUrl.searchParams.append("redirect", redirect);
+    process.stdout.write("\x1B[2K\r");
+    relinka(
+      "log",
+      "The following URL will be opened in your default browser (use Ctrl+Click to open):",
+      confirmationUrl.toString()
+    );
+    try {
+      await open(confirmationUrl.toString());
+      relinka("verbose", "Opened browser with confirmation URL.");
+    } catch (error) {
+      relinka(
+        "error",
+        "Failed to open the browser automatically:",
+        error instanceof Error ? error.message : String(error)
+      );
+      relinka(
+        "error",
+        "Please manually open the following URL in your browser:",
+        confirmationUrl.toString()
+      );
+    }
+    spinner.setText(
+      ` Please visit it and confirm there if you see the same code: ${re.bold(code)}`
+    );
+    const authTimeout = setTimeout(
+      () => {
+        relinka("error", "Authentication timed out.");
+        server.close(() => {
+          relinka("error", "Local server closed due to timeout.");
+          process.exit(1);
+        });
+      },
+      5 * 60 * 1e3
+    );
+    try {
+      const authData = await authPromise;
+      clearTimeout(authTimeout);
+      relinka("verbose", `Authentication data received: ${JSON.stringify(authData)}`);
+      if (authData.cancelled) {
+        throw new UserCancellationError("Login process cancelled by user.");
+      }
+      await updateReliverseMemory({
+        code: authData.code,
+        key: authData.key
+      });
+      server.close(() => {
+        relinka("verbose", "Wrote auth data to memory. To view it, type:", `code ${memoryPath}`);
+        relinka("verbose", "Local server closed after successful authentication.");
+      });
+      spinner.stop();
+      relinka("log", cliDomainDocs);
+      return;
+    } catch (error) {
+      clearTimeout(authTimeout);
+      if (error instanceof UserCancellationError) {
+        spinner.setText("Login cancelled. See you next time \u{1F44B}");
+        server.close(() => {
+          relinka("verbose", "Local server closed due to user cancellation.");
+          process.exit(0);
+        });
+      } else {
+        server.close(() => {
+          relinka("verbose", "Local server closed due to authentication failure.");
+        });
+        spinner.stop();
+        throw error;
+      }
+    }
+  } catch (error) {
+    spinner.stop();
+    relinka("error", "Authentication failed!");
+    throw error;
+  }
+}
+export async function authCheck(isDev, memory, useLocalhost) {
+  const isAuthenticated = memory.code && memory.code !== "" && memory.key && memory.key !== "";
+  if (!isAuthenticated) {
+    await showAnykeyPrompt();
+    await auth({ isDev, useLocalhost });
+    const updatedMemory = await getOrCreateReliverseMemory();
+    const authSuccess = updatedMemory.code && updatedMemory.code !== "" && updatedMemory.key && updatedMemory.key !== "";
+    if (!authSuccess) {
+      relinka("error", "Authentication failed. Please try again.");
+      process.exit(1);
+    }
+  }
+}

package/bin/app/logout/cmd.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    dev: {
+        type: "boolean";
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/logout/cmd.js

@@ -0,0 +1,47 @@
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt, defineCommand, deleteLastLine, msg } from "@reliverse/rempts";
+import { memoryPath } from "../config/constants.js";
+import { deleteMemory } from "./logout-impl.js";
+const isConfigExists = async () => {
+  if (await fs.pathExists(memoryPath)) {
+    return true;
+  }
+  return false;
+};
+export default defineCommand({
+  meta: {
+    name: "logout",
+    description: "Ask rse to forget your data",
+    hidden: true
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Run the CLI in dev mode"
+    }
+  },
+  run: async ({ args }) => {
+    if (!await isConfigExists()) {
+      relinka("success", "You're not logged in.");
+      if (args.dev) {
+        relinka("info", "Try `bun dev:login` cmd.");
+      }
+      process.exit(0);
+    }
+    const danger = await confirmPrompt({
+      title: "Are you sure you want to log out? rse will delete its local memory. This action cannot be undone.",
+      titleColor: "redBright"
+    });
+    if (danger) {
+      await deleteMemory();
+      deleteLastLine();
+      msg({
+        type: "M_BAR",
+        borderColor: "dim"
+      });
+      relinka("success", "You're logged out now! \u{1F44B}");
+      process.exit(0);
+    }
+  }
+});

package/bin/app/logout/logout-impl.d.ts

@@ -0,0 +1 @@
+export declare function deleteMemory(): Promise<void>;

package/bin/app/logout/logout-impl.js

@@ -0,0 +1,20 @@
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { memoryPath } from "../config/constants.js";
+export async function deleteMemory() {
+  relinka("verbose", `Deleting config file: ${memoryPath}`);
+  try {
+    if (await fs.pathExists(memoryPath)) {
+      await fs.remove(memoryPath);
+      relinka("verbose", "Config file deleted successfully");
+    } else {
+      relinka("verbose", "Config file not found");
+    }
+  } catch (error) {
+    relinka(
+      "error",
+      "Failed to delete config file",
+      error instanceof Error ? error.message : "Unknown error"
+    );
+  }
+}