@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/invoke/mod.d.ts

@@ -1,59 +0,0 @@
-/**
- * # 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
- */
-declare const _default: import("@reliverse/rempts").Command<{
-    dev: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-    command: {
-        type: "string";
-        description: string;
-        required: false;
-    };
-    args: {
-        type: "array";
-        description: string;
-        required: false;
-    };
-    chain: {
-        type: "string";
-        description: string;
-        required: false;
-    };
-    dryRun: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-    allowDangerous: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-    verbose: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-    interactive: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-}>;
-export default _default;

package/bin/impl/invoke/mod.js

@@ -1,353 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt, defineCommand, inputPrompt, selectPrompt } from "@reliverse/rempts";
-import { execaCommand } from "execa";
-import { getOrCreateReliverseConfig } from "../config/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 getOrCreateReliverseConfig({
-      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/impl/login/login-impl.d.ts

@@ -1,6 +0,0 @@
-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/impl/login/login-impl.js

@@ -1,179 +0,0 @@
-import { setTimeout } from "node:timers";
-import { re } from "@reliverse/relico";
-import { relinka } from "@reliverse/relinka";
-import { createSpinner } from "@reliverse/rempts";
-import { listen } from "async-listen";
-import http from "http";
-import { customAlphabet } from "nanoid";
-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 = createSpinner({
-    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.text = ` 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.succeed("Authenticated!");
-      relinka("log", cliDomainDocs);
-      return;
-    } catch (error) {
-      clearTimeout(authTimeout);
-      if (error instanceof UserCancellationError) {
-        spinner.text = "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.fail("Authentication failed");
-        throw error;
-      }
-    }
-  } catch (error) {
-    spinner.fail("Authentication failed");
-    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/impl/logout/logout-impl.d.ts

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

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

@@ -1,20 +0,0 @@
-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"
-    );
-  }
-}