@reliverse/dler 1.7.92 → 1.7.94

package/bin/app/get/get-impl/get-core.js

@@ -0,0 +1,453 @@
+import { createWriteStream } from "node:fs";
+import { arch, homedir, platform } from "node:os";
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { execa } from "execa";
+import { lookpath } from "lookpath";
+export async function installDlerStandalone(installDir, appsPath, args) {
+  relinka("info", "Installing dler standalone binary...");
+  await checkGlobalDlerConflicts(args.force);
+  const repository = "reliverse/dler";
+  const currentMeta = await getCurrentMeta(appsPath, "dler");
+  if (!args.force && currentMeta) {
+    const latestVersion = await getLatestVersion(repository);
+    if (currentMeta.version === latestVersion) {
+      relinka("success", `dler ${latestVersion} is already installed and up-to-date`);
+      return;
+    } else {
+      relinka("info", `Upgrading dler from ${currentMeta.version} to ${latestVersion}`);
+    }
+  }
+  const binaryInfo = getDlerBinaryInfo();
+  const downloadUrl = `https://github.com/${repository}/releases/${args.version}/download/${binaryInfo.filename}`;
+  const binaryPath = path.resolve(installDir, binaryInfo.localName);
+  if (args["dry-run"]) {
+    relinka("info", "Dry run mode - would download:");
+    relinka("verbose", `  From: ${downloadUrl}`);
+    relinka("verbose", `  To: ${binaryPath}`);
+    return;
+  }
+  await downloadBinary(downloadUrl, binaryPath);
+  await makeExecutable(binaryPath);
+  const actualVersion = await getLatestVersion(repository);
+  const meta = {
+    version: actualVersion,
+    downloadUrl,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    binary: binaryInfo.localName,
+    repository
+  };
+  await updateAppsJson(appsPath, "dler", meta);
+  relinka("success", `dler ${actualVersion} installed successfully to ${binaryPath}`);
+  if (!args["skip-path"]) {
+    await ensureInPath(installDir);
+  }
+}
+export async function installFromGitHub(repoUrl, installDir, appsPath, args) {
+  relinka("info", `Installing binary from ${repoUrl}...`);
+  const repository = normalizeRepoUrl(repoUrl);
+  const release = await getGitHubRelease(repository, args.version);
+  if (!release) {
+    throw new Error(`Release ${args.version} not found for ${repository}`);
+  }
+  const asset = findBinaryAsset(release.assets, args.binary);
+  if (!asset) {
+    relinka("error", "Available assets:");
+    release.assets.forEach((a) => relinka("verbose", `  - ${a.name}`));
+    throw new Error(`No suitable binary found for your platform`);
+  }
+  const binaryName = args.binary || asset.name;
+  const binaryPath = path.resolve(installDir, binaryName);
+  const binaryKey = path.basename(binaryName, path.extname(binaryName));
+  if (args["dry-run"]) {
+    relinka("info", "Dry run mode - would download:");
+    relinka("verbose", `  Asset: ${asset.name}`);
+    relinka("verbose", `  From: ${asset.browser_download_url}`);
+    relinka("verbose", `  To: ${binaryPath}`);
+    return;
+  }
+  await downloadBinary(asset.browser_download_url, binaryPath);
+  await makeExecutable(binaryPath);
+  const meta = {
+    version: release.tag_name,
+    downloadUrl: asset.browser_download_url,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    binary: binaryName,
+    repository
+  };
+  await updateAppsJson(appsPath, binaryKey, meta);
+  relinka("success", `${binaryName} ${release.tag_name} installed successfully to ${binaryPath}`);
+  if (!args["skip-path"]) {
+    await ensureInPath(installDir);
+  }
+}
+function getDlerBinaryInfo() {
+  const os = platform();
+  if (os === "darwin") {
+    return {
+      filename: "dler-darwin-arm64",
+      localName: "dler"
+    };
+  } else if (os === "linux") {
+    return {
+      filename: "dler-linux",
+      localName: "dler"
+    };
+  } else if (os === "win32") {
+    return {
+      filename: "dler-windows.exe",
+      localName: "dler.exe"
+    };
+  } else {
+    throw new Error(`Unsupported platform: ${os}`);
+  }
+}
+function findBinaryAsset(assets, specificBinary) {
+  if (specificBinary) {
+    return assets.find((asset) => asset.name === specificBinary);
+  }
+  const os = platform();
+  const architecture = arch();
+  const patterns = [];
+  if (os === "darwin") {
+    patterns.push("darwin", "macos", "mac", "osx");
+    if (architecture === "arm64") {
+      patterns.push("arm64", "aarch64");
+    } else {
+      patterns.push("amd64", "x64", "x86_64");
+    }
+  } else if (os === "linux") {
+    patterns.push("linux");
+    if (architecture === "arm64") {
+      patterns.push("arm64", "aarch64");
+    } else {
+      patterns.push("amd64", "x64", "x86_64");
+    }
+  } else if (os === "win32") {
+    patterns.push("windows", "win", ".exe");
+    patterns.push("amd64", "x64", "x86_64");
+  }
+  return assets.find((asset) => {
+    const name = asset.name.toLowerCase();
+    return patterns.some((pattern) => name.includes(pattern.toLowerCase()));
+  });
+}
+async function getCurrentMeta(appsPath, binaryKey) {
+  try {
+    if (await fs.pathExists(appsPath)) {
+      const content = await fs.readFile(appsPath, "utf8");
+      const allMeta = JSON.parse(content);
+      return allMeta[binaryKey] || null;
+    }
+  } catch {
+  }
+  return null;
+}
+async function updateAppsJson(appsPath, binaryKey, meta) {
+  let allMeta = {};
+  try {
+    if (await fs.pathExists(appsPath)) {
+      const content = await fs.readFile(appsPath, "utf8");
+      allMeta = JSON.parse(content);
+    }
+  } catch {
+  }
+  allMeta[binaryKey] = meta;
+  await fs.writeFile(appsPath, JSON.stringify(allMeta, null, 2), "utf8");
+}
+export async function checkPowerShellVersion() {
+  relinka("info", "Checking PowerShell version...");
+  try {
+    const pwshPath = await lookpath("pwsh");
+    let powershellCmd = "powershell";
+    let isPwsh = false;
+    if (pwshPath) {
+      powershellCmd = "pwsh";
+      isPwsh = true;
+    }
+    const { stdout } = await execa(powershellCmd, [
+      "-Command",
+      "$PSVersionTable.PSVersion.ToString()"
+    ]);
+    const versionString = stdout.trim();
+    relinka(
+      "info",
+      `Found ${isPwsh ? "PowerShell Core" : "Windows PowerShell"} version: ${versionString}`
+    );
+    const versionMatch = versionString.match(/^(\d+)\.(\d+)(?:\.(\d+))?/);
+    if (!versionMatch || !versionMatch[1] || !versionMatch[2]) {
+      throw new Error(`Unable to parse PowerShell version: ${versionString}`);
+    }
+    const major = Number.parseInt(versionMatch[1], 10);
+    const minor = Number.parseInt(versionMatch[2], 10);
+    const isVersionValid = major > 7 || major === 7 && minor >= 5;
+    if (!isVersionValid) {
+      relinka("error", "\u274C PowerShell 7.5+ is required for dler installation on Windows");
+      relinka("verbose", `   Current version: ${versionString}`);
+      relinka("verbose", `   Required version: 7.5.0 or higher`);
+      relinka("verbose", "");
+      relinka("info", "\u{1F527} To install PowerShell 7.5+:");
+      relinka("verbose", "   \u2022 Visit: https://github.com/PowerShell/PowerShell/releases");
+      relinka(
+        "verbose",
+        "   \u2022 Or use Windows Package Manager: winget install Microsoft.PowerShell"
+      );
+      relinka("verbose", "   \u2022 Or use Chocolatey: choco install powershell-core");
+      relinka("verbose", "   \u2022 Or use Scoop: scoop install pwsh");
+      relinka("verbose", "");
+      relinka("info", "After installation, restart your terminal and try again.");
+      process.exit(1);
+    }
+    relinka("verbose", `PowerShell ${versionString} meets the requirements`);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Command failed")) {
+      relinka("error", "\u274C PowerShell not found or not working properly");
+      relinka("info", "Please ensure PowerShell 7.5+ is installed and accessible");
+    } else {
+      throw error;
+    }
+    process.exit(1);
+  }
+}
+async function checkGlobalDlerConflicts(force) {
+  const packageManagers = ["npm", "yarn", "pnpm", "bun"];
+  const conflicts = [];
+  for (const pm of packageManagers) {
+    const pmPath = await lookpath(pm);
+    if (!pmPath) continue;
+    try {
+      let isInstalled = false;
+      if (pm === "npm") {
+        const { stdout } = await execa("npm", ["list", "-g", "--depth=0", "@reliverse/dler"]);
+        isInstalled = stdout.includes("@reliverse/dler");
+      } else if (pm === "yarn") {
+        try {
+          const { stdout } = await execa("yarn", ["global", "list"]);
+          isInstalled = stdout.includes("@reliverse/dler");
+        } catch {
+          try {
+            const { stdout } = await execa("yarn", [
+              "global",
+              "list",
+              "--pattern",
+              "@reliverse/dler"
+            ]);
+            isInstalled = stdout.includes("@reliverse/dler");
+          } catch {
+          }
+        }
+      } else if (pm === "pnpm") {
+        const { stdout } = await execa("pnpm", ["list", "-g", "@reliverse/dler"]);
+        isInstalled = stdout.includes("@reliverse/dler");
+      } else if (pm === "bun") {
+        const { stdout } = await execa("bun", ["pm", "ls", "-g"]);
+        isInstalled = stdout.includes("@reliverse/dler");
+      }
+      if (isInstalled) {
+        const removeCommand = pm === "npm" ? "uninstall" : pm === "yarn" ? "global remove" : pm === "pnpm" ? "remove" : "remove";
+        conflicts.push({
+          manager: pm,
+          command: pm === "yarn" ? `${pm} ${removeCommand} @reliverse/dler` : `${pm} ${removeCommand} -g @reliverse/dler`
+        });
+      }
+    } catch {
+    }
+  }
+  if (conflicts.length > 0 && !force) {
+    relinka("warn", "\u26A0\uFE0F  Detected globally installed dler via package manager(s):");
+    conflicts.forEach((conflict) => {
+      relinka(
+        "log",
+        `  \u{1F4E6} ${conflict.manager.toUpperCase()}: Found @reliverse/dler installed globally`
+      );
+    });
+    relinka("warn", "\n\u{1F527} To avoid conflicts, please remove the global installation(s) first:");
+    conflicts.forEach((conflict) => {
+      relinka("verbose", `  ${conflict.command}`);
+    });
+    relinka(
+      "info",
+      "\n\u{1F4A1} Then RESTART your terminal and run 'dler get' again to install the standalone binary."
+    );
+    relinka("info", "Or use --force to proceed anyway (not recommended).");
+    process.exit(1);
+  } else if (conflicts.length > 0 && force) {
+    relinka("warn", "\u26A0\uFE0F  Proceeding with --force despite global dler installation conflicts");
+  }
+}
+async function getLatestVersion(repository) {
+  try {
+    const response = await fetch(`https://api.github.com/repos/${repository}/releases/latest`);
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status}`);
+    }
+    const release = await response.json();
+    return release.tag_name;
+  } catch (error) {
+    throw new Error(
+      `Failed to get latest version: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function getGitHubRelease(repository, version) {
+  try {
+    const url = version === "latest" ? `https://api.github.com/repos/${repository}/releases/latest` : `https://api.github.com/repos/${repository}/releases/tags/${version}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      if (response.status === 404) {
+        return null;
+      }
+      throw new Error(`GitHub API error: ${response.status}`);
+    }
+    return await response.json();
+  } catch (error) {
+    throw new Error(
+      `Failed to get release info: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function normalizeRepoUrl(url) {
+  if (url.includes("github.com")) {
+    const match = url.match(/github\.com\/([^/]+\/[^/]+)/);
+    if (match && match[1]) {
+      return match[1].replace(/\.git$/, "");
+    }
+  }
+  if (url.includes("/") && !url.includes("://")) {
+    return url;
+  }
+  throw new Error(`Invalid repository URL format: ${url}`);
+}
+async function downloadBinary(url, targetPath) {
+  relinka("info", `Downloading from ${url}...`);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+  }
+  if (!response.body) {
+    throw new Error("No response body");
+  }
+  const fileStream = createWriteStream(targetPath);
+  const reader = response.body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      fileStream.write(Buffer.from(value));
+    }
+  } finally {
+    fileStream.end();
+    reader.releaseLock();
+  }
+  relinka("success", "Download completed");
+}
+async function makeExecutable(filePath) {
+  if (platform() !== "win32") {
+    await fs.chmod(filePath, 493);
+  }
+}
+async function addToWindowsPath(installDir) {
+  const psScript = `
+    function Refresh-Path {
+      $paths = @(
+        [System.Environment]::GetEnvironmentVariable("Path", "Machine"),
+        [System.Environment]::GetEnvironmentVariable("Path", "User"),
+        [System.Environment]::GetEnvironmentVariable("Path", "Process")
+      )
+      $uniquePaths = $paths |
+        Where-Object { $_ } |
+        ForEach-Object { $_.Split(';', [StringSplitOptions]::RemoveEmptyEntries) } |
+        Where-Object { $_ -and (Test-Path $_) } |
+        Select-Object -Unique
+      $env:Path = ($uniquePaths -join ';').TrimEnd(';')
+    }
+    function Add-To-User-Path {
+      param([string]$Directory)
+      $absolutePath = Resolve-Path $Directory -ErrorAction SilentlyContinue
+      if (-not $absolutePath) {
+        $absolutePath = $Directory
+      }
+      $currentPath = [Environment]::GetEnvironmentVariable("Path", "User")
+      if (-not $currentPath) { $currentPath = "" }
+      # Check if already in PATH
+      $pathArray = $currentPath.Split(';', [StringSplitOptions]::RemoveEmptyEntries)
+      if ($pathArray -contains $absolutePath) {
+        Write-Host "Directory already in PATH"
+        return
+      }
+      # Add to PATH with length checking (User PATH limit is typically 2048)
+      $newPath = $currentPath.TrimEnd(";") + ";" + $absolutePath
+      if ($newPath.Length -ge 2048) {
+        Write-Warning "PATH is getting long, removing duplicates..."
+        # Remove duplicates and non-existent paths
+        $cleanPaths = $pathArray | 
+          Where-Object { $_ -and (Test-Path $_) } |
+          Select-Object -Unique
+        $cleanPaths += $absolutePath
+        $newPath = $cleanPaths -join ';'
+        # If still too long, remove older entries
+        while ($newPath.Length -ge 2048 -and $cleanPaths.Count -gt 1) {
+          $cleanPaths = $cleanPaths[1..$cleanPaths.Count]
+          $newPath = $cleanPaths -join ';'
+        }
+      }
+      Write-Host "Adding $absolutePath to User PATH..."
+      [Environment]::SetEnvironmentVariable("Path", $newPath, "User")
+      Refresh-Path
+      Write-Host "PATH updated successfully"
+    }
+    Add-To-User-Path '${installDir.replace(/\\/g, "\\\\").replace(/'/g, "''")}'
+  `.trim();
+  const pwshPath = await lookpath("pwsh");
+  const powershellCmd = pwshPath || "powershell";
+  await execa(powershellCmd, ["-Command", psScript]);
+}
+async function ensureInPath(installDir) {
+  const testBinary = await lookpath("dler");
+  if (testBinary && testBinary.includes(installDir)) {
+    relinka("success", `${installDir} is already in PATH`);
+    return;
+  }
+  relinka("info", "Adding to PATH...");
+  const os = platform();
+  const homeDir = homedir();
+  if (os === "win32") {
+    try {
+      await addToWindowsPath(installDir);
+      relinka("success", `Added ${installDir} to PATH`);
+      relinka("info", "Please restart your terminal for PATH changes to take effect");
+    } catch (error) {
+      relinka("warn", `Failed to automatically modify PATH: ${error}`);
+      relinka("warn", "Please add manually:");
+      relinka("verbose", `Add ${installDir} to your PATH environment variable`);
+      relinka(
+        "log",
+        "You can do this through Environment Variables > System Properties > Path > Edit"
+      );
+    }
+  } else {
+    const shellRc = os === "darwin" ? path.resolve(homeDir, ".zshrc") : path.resolve(homeDir, ".bashrc");
+    try {
+      let rcContent = "";
+      if (await fs.pathExists(shellRc)) {
+        rcContent = await fs.readFile(shellRc, "utf8");
+      }
+      const pathExport = `export PATH="${installDir}:$PATH"`;
+      if (!rcContent.includes(pathExport)) {
+        rcContent += `
+# Added by dler get command
+${pathExport}
+`;
+        await fs.writeFile(shellRc, rcContent, "utf8");
+        relinka("success", `Added to PATH in ${shellRc}`);
+        relinka("info", "Please restart your terminal or run: source " + shellRc);
+      } else {
+        relinka("info", "PATH export already exists in " + shellRc);
+      }
+    } catch (error) {
+      relinka("warn", `Could not modify shell RC file: ${error}`);
+      relinka("info", `Please manually add ${installDir} to your PATH`);
+    }
+  }
+}

package/bin/app/get/get-mod.js

@@ -0,0 +1,68 @@
+import fs from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import path from "node:path";
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import {
+  checkPowerShellVersion,
+  installDlerStandalone,
+  installFromGitHub
+} from "./get-impl/get-core.js";
+export default defineCommand({
+  meta: {
+    name: "get",
+    version: "1.0.0",
+    description: "Download and install GitHub release binaries. Installs dler standalone by default."
+  },
+  args: defineArgs({
+    url: {
+      type: "string",
+      description: "GitHub repository URL (owner/repo format) to download from"
+    },
+    version: {
+      type: "string",
+      description: "Specific version to download (defaults to latest)",
+      default: "latest"
+    },
+    binary: {
+      type: "string",
+      description: "Specific binary name to download (auto-detected if not provided)"
+    },
+    force: {
+      type: "boolean",
+      description: "Force reinstallation even if already installed",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be downloaded without installing",
+      default: false
+    },
+    "skip-path": {
+      type: "boolean",
+      description: "Skip adding to PATH",
+      default: false
+    }
+  }),
+  async run({ args }) {
+    try {
+      if (platform() === "win32") {
+        await checkPowerShellVersion();
+      }
+      const installDir = path.resolve(homedir(), ".reliverse", "dler");
+      const appsPath = path.resolve(homedir(), ".reliverse", "apps.json");
+      await fs.mkdir(installDir, { recursive: true });
+      if (!args.url) {
+        await installDlerStandalone(installDir, appsPath, args);
+      } else {
+        await installFromGitHub(args.url, installDir, appsPath, args);
+      }
+    } catch (error) {
+      relinka(
+        "error",
+        `Installation failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  }
+});

package/bin/app/help/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/help/cmd.js

@@ -0,0 +1,23 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+export default defineCommand({
+  meta: {
+    name: "help",
+    description: "Displays the help message",
+    hidden: true
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Displays the help message for the dev command"
+    }
+  },
+  run: ({ args }) => {
+    if (args.dev) {
+      relinka("info", "Use `bun dev --help` instead.");
+    } else {
+      relinka("info", "Use `rse --help` instead.");
+    }
+    process.exit(0);
+  }
+});

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

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

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

@@ -0,0 +1,23 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+export default defineCommand({
+  meta: {
+    name: "help",
+    description: "Displays the help message",
+    hidden: true
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Displays the help message for the dev command"
+    }
+  },
+  run: ({ args }) => {
+    if (args.dev) {
+      relinka("info", "Use `bun dev --help` instead.");
+    } else {
+      relinka("info", "Use `rse --help` instead.");
+    }
+    process.exit(0);
+  }
+});

package/bin/app/init/cmd-2.d.ts

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

package/bin/app/init/cmd-2.js

@@ -0,0 +1,68 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import { getOrCreateRseConfig } from "../config/cfg-core.js";
+import { showManualBuilderMenu } from "./init-utils/init-impl.js";
+import { initMinimalrseProject } from "./init-utils/init-utils.js";
+import { askProjectName } from "../utils/prompts/askProjectName.js";
+import { getOrCreateReliverseMemory } from "../utils/reliverseMemory.js";
+import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
+export default defineCommand({
+  meta: {
+    name: "init",
+    description: "Initialize a new rse project with minimal setup"
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Runs in dev mode",
+      required: false
+    },
+    target: {
+      type: "string",
+      description: "Path to the directory (opens project selector if not provided)",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const { dev: isDev, target } = args;
+      const cwd = getCurrentWorkingDirectory();
+      const memory = await getOrCreateReliverseMemory();
+      const { config } = await getOrCreateRseConfig({
+        projectPath: cwd,
+        isDev,
+        overrides: {}
+      });
+      const trimmedTarget = typeof target === "string" ? target.trim() : "";
+      const explicitTargetProvided = trimmedTarget.length > 0;
+      const projectName = explicitTargetProvided ? trimmedTarget : await askProjectName({});
+      const projectPath = isDev ? path.resolve(cwd, `tests-runtime/${projectName}`) : path.resolve(cwd, projectName);
+      if (await fs.pathExists(projectPath)) {
+        throw new Error(`Project directory ${projectPath} already exists`);
+      }
+      if (explicitTargetProvided) {
+        await initMinimalrseProject(projectPath, projectName, isDev);
+      } else {
+        await showManualBuilderMenu({
+          projectName,
+          cwd,
+          isDev,
+          memory,
+          config,
+          skipPrompts: false
+        });
+      }
+      relinka("success", "Project initialization completed successfully.");
+      process.exit(0);
+    } catch (error) {
+      if (error instanceof Error) {
+        relinka("error", "Error during project initialization:", error.message);
+      } else {
+        relinka("error", "Error during project initialization:", String(error));
+      }
+      process.exit(1);
+    }
+  }
+});

package/bin/app/init/init-utils/init-impl.d.ts

@@ -0,0 +1,6 @@
+import type { ShowMenuResult } from "../../add/add-local/core/types.js";
+import type { ParamsOmitReli } from "../../types/mod.js";
+/**
+ * Main entry point for the manual builder menu.
+ */
+export declare function showManualBuilderMenu(params: ParamsOmitReli): Promise<ShowMenuResult>;