@reliverse/dler 1.7.153 → 2.0.1

package/bin/impl/init/use-template/cp-modules/cli-main-modules/cli-menu-items/showCloneProjectMenu.js

@@ -1,206 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt, inputPrompt, multiselectPrompt, selectPrompt } from "@reliverse/rempts";
-import { getUserPkgManager } from "../../../../../utils/dependencies/getUserPkgManager.js";
-import { handleDownload } from "../../../../../utils/downloading/handleDownload.js";
-import { ensureGithubToken } from "../../../../../utils/instanceGithub.js";
-import { askProjectName } from "../../../../../utils/prompts/askProjectName.js";
-import { cd } from "../../../../../utils/terminalHelpers.js";
-function normalizeGitHubUrl(url) {
-  return url.trim().replace(/^https?:\/\/(www\.)?(github|gitlab|bitbucket|sourcehut)\.com\//i, "").replace(/^(github|gitlab|bitbucket|sourcehut)\.com\//i, "").replace(/\.git$/i, "");
-}
-const REPO_OWNERS = {
-  blefnk: [
-    "all-in-one-nextjs-template",
-    "astro-starlight-template",
-    "create-next-app",
-    "create-t3-app",
-    "relivator-nextjs-template",
-    "versator-nextjs-template"
-  ],
-  rse: ["template-browser-extension", "acme", "cli", "pm", "prompts", "relico", "relinka"],
-  onwidget: ["astrowind"],
-  "shadcn-ui": ["taxonomy"],
-  "47ng": ["nuqs"],
-  biomejs: ["biome"],
-  pmndrs: ["zustand"],
-  unjs: ["template"],
-  "webpro-nl": ["knip"]
-};
-function createMenuOptions(repos, owner, config) {
-  const customRepos = (config.customUserFocusedRepos ?? []).concat(config.customDevsFocusedRepos ?? []).map(normalizeGitHubUrl).filter((repo) => repo.startsWith(`${owner}/`)).map((repo) => repo.split("/")[1]).filter((repo) => repo !== void 0);
-  const allRepos = config.hideRepoSuggestions && customRepos.length > 0 ? customRepos : [...repos, ...customRepos];
-  if (!config.multipleRepoCloneMode) {
-    return [
-      {
-        label: "\u{1F4DD} I want to provide a custom repository name",
-        value: "custom"
-      },
-      ...allRepos.map(
-        (repo) => ({
-          label: repo,
-          value: repo,
-          hint: customRepos.includes(repo) ? "custom" : void 0
-        })
-      )
-    ];
-  }
-  return allRepos.map(
-    (repo) => ({
-      label: repo,
-      value: repo,
-      hint: customRepos.includes(repo) ? "custom" : void 0
-    })
-  );
-}
-async function promptForRepo({
-  title,
-  owner,
-  options,
-  config
-}) {
-  if (config.multipleRepoCloneMode) {
-    const selections = await multiselectPrompt({ title, options });
-    if (selections.length === 0) {
-      relinka("error", "Please select at least one repository.");
-      return promptForRepo({ title, owner, options, config });
-    }
-    const isCustomMap = /* @__PURE__ */ new Map();
-    const repos = selections.map((repo) => {
-      const fullRepo = `${owner}/${repo}`;
-      isCustomMap.set(fullRepo, false);
-      return fullRepo;
-    });
-    return { repos, isCustomMap };
-  } else {
-    const selection = await selectPrompt({ title, options });
-    if (selection === "custom") {
-      const customRepo = await inputPrompt({
-        title: `Enter a repository name for ${owner}`,
-        content: `This will be combined as ${owner}/<your-input>`
-      });
-      return { repo: `${owner}/${customRepo}`, isCustom: true };
-    }
-    return { repo: `${owner}/${selection}`, isCustom: false };
-  }
-}
-async function downloadAndSetupRepo(owner, repoFullName, config, memory, isDev, cwd, isCustom) {
-  let privacy = "public";
-  if (!REPO_OWNERS[owner]?.includes(repoFullName.split("/")[1])) {
-    privacy = await selectPrompt({
-      title: `Is repo ${repoFullName} public or private?`,
-      options: [
-        { label: "Public", value: "public" },
-        { label: "Private", value: "private" }
-      ]
-    });
-  }
-  const { packageManager } = await getUserPkgManager();
-  let shouldInstallDeps = false;
-  if (!isDev) {
-    shouldInstallDeps = await confirmPrompt({
-      title: "Do you want me to install dependencies?",
-      content: `I can run "${packageManager} install" in the directory of the cloned repo.`
-    });
-  }
-  const projectName = await askProjectName({ repoName: repoFullName });
-  const gitPreference = await selectPrompt({
-    title: "How would you like to handle Git history?",
-    content: `(project: ${projectName} | repo: ${repoFullName})`,
-    options: [
-      {
-        label: "Preserve original Git history",
-        hint: "keeps the original .git folder",
-        value: "preserve"
-      },
-      {
-        label: "Start fresh Git history",
-        hint: "initializes a new .git folder",
-        value: "fresh"
-      }
-    ]
-  });
-  let githubToken = "";
-  if (privacy === "private") {
-    githubToken = await ensureGithubToken(memory, "prompt");
-  }
-  const { source, dir } = await handleDownload({
-    cwd,
-    isDev,
-    skipPrompts: false,
-    projectPath: "",
-    projectName,
-    selectedRepo: repoFullName,
-    githubToken,
-    preserveGit: gitPreference === "preserve",
-    config: gitPreference === "fresh" ? config : void 0,
-    install: shouldInstallDeps,
-    isCustom,
-    isTemplateDownload: false,
-    cache: false
-  });
-  relinka("success", `\u2705 ${source} was downloaded to ${dir}`);
-}
-export async function showCloneProjectMenu({
-  isDev,
-  cwd,
-  config,
-  memory
-}) {
-  if (isDev) {
-    await cd("tests-runtime");
-  }
-  relinka(
-    "success",
-    "Please note: This menu only allows cloning repositories.",
-    "If you want a fully personalized project bootstrapped with a desired template, re-run the CLI and choose the `\u2728 Create a brand new project` option instead."
-  );
-  const ownerOptions = [
-    ...Object.keys(REPO_OWNERS).map((owner2) => ({
-      label: owner2,
-      value: owner2
-    })),
-    { label: "\u{1F4DD} Enter a custom owner", value: "custom" },
-    { label: "\u{1F448} Exit", value: "exit" }
-  ];
-  const selectedOwner = await selectPrompt({
-    title: "Select or enter a repository owner",
-    options: ownerOptions
-  });
-  if (selectedOwner === "exit") {
-    relinka("info", "Exiting without cloning any repository.");
-    return;
-  }
-  const owner = selectedOwner === "custom" ? await inputPrompt({
-    title: "Enter the GitHub username or organization"
-  }) : selectedOwner;
-  const ownerRepos = REPO_OWNERS[owner] || [];
-  const repoPromptResult = await promptForRepo({
-    title: `Select repositories from ${owner}`,
-    owner,
-    options: createMenuOptions(ownerRepos, owner, config),
-    config
-  });
-  if ("repos" in repoPromptResult) {
-    for (const repo of repoPromptResult.repos) {
-      await downloadAndSetupRepo(
-        owner,
-        repo,
-        config,
-        memory,
-        isDev,
-        cwd,
-        repoPromptResult.isCustomMap.get(repo) || false
-      );
-    }
-  } else {
-    await downloadAndSetupRepo(
-      owner,
-      repoPromptResult.repo,
-      config,
-      memory,
-      isDev,
-      cwd,
-      repoPromptResult.isCustom
-    );
-  }
-}

package/bin/impl/init/use-template/cp-modules/cli-main-modules/modules/showAnykeyPrompt.d.ts

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

package/bin/impl/init/use-template/cp-modules/cli-main-modules/modules/showAnykeyPrompt.js

@@ -1,9 +0,0 @@
-import { re } from "@reliverse/relico";
-import { anykeyPrompt } from "@reliverse/rempts";
-export async function showAnykeyPrompt() {
-  const notification = `\u{1F916} Hello, my name is rseyour assistant for creating new web projects, integrating new features, and making advanced codebase modifications.
-\u2728 I'm constantly evolving, with even more features soon! In the future, I'll be able to work with not only web apps. Let's get started!
-\u2502  ============================
-\u2502  ${re.bold("Press any key to continue...")}`;
-  await anykeyPrompt(notification);
-}

package/bin/impl/init/use-template/cp-modules/compose-env-file/cef-impl.d.ts

@@ -1,16 +0,0 @@
-import type { ReliverseConfig } from "../../../../schema/mod.js";
-export declare function ensureExampleExists(projectPath: string, fallbackEnvExampleURL: string): Promise<boolean>;
-export declare function ensureEnvExists(projectPath: string): Promise<boolean>;
-/**
- * Revised getMissingKeys:
- * 1) Reads all required keys from .env.example
- * 2) Parses .env to see which keys are present & non-empty
- * 3) Returns only those that are truly missing or empty
- */
-export declare function getMissingKeys(projectPath: string): Promise<string[]>;
-export declare function copyFromExisting(projectPath: string, sourcePath: string): Promise<boolean>;
-export declare function getEnvPath(projectPath: string): string;
-export declare function fetchEnvExampleContent(urlResource: string): Promise<string | null>;
-export declare function promptAndSetMissingValues(missingKeys: string[], envPath: string, maskInput: boolean, config: ReliverseConfig, wasEnvCopied?: boolean, isMrse?: boolean, projectPath?: string, skipPrompts?: boolean): Promise<void>;
-export declare function saveLastEnvFilePath(envPath: string): Promise<void>;
-export declare function getLastEnvFilePath(): Promise<string | null>;

package/bin/impl/init/use-template/cp-modules/compose-env-file/cef-impl.js

@@ -1,400 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt, inputPrompt, multiselectPrompt } from "@reliverse/rempts";
-import { eq } from "drizzle-orm";
-import { ofetch } from "ofetch";
-import open from "open";
-import { getRandomValues } from "uncrypto";
-import { db } from "../../../../db/client.js";
-import { decrypt, encrypt } from "../../../../db/config.js";
-import { userDataTable } from "../../../../db/schema.js";
-import { KNOWN_SERVICES } from "./cef-keys.js";
-function getEnvPaths(projectPath) {
-  const projectRoot = path.resolve(projectPath);
-  return {
-    projectRoot,
-    exampleEnvPath: path.join(projectRoot, ".env.example"),
-    envPath: path.join(projectRoot, ".env")
-  };
-}
-async function safeReadFile(filePath) {
-  try {
-    return await fs.readFile(filePath, "utf8");
-  } catch {
-    return null;
-  }
-}
-async function safeWriteFile(filePath, content) {
-  try {
-    await fs.writeFile(filePath, content);
-    return true;
-  } catch {
-    return false;
-  }
-}
-export async function ensureExampleExists(projectPath, fallbackEnvExampleURL) {
-  const { exampleEnvPath } = getEnvPaths(projectPath);
-  try {
-    if (await fs.pathExists(exampleEnvPath)) {
-      return true;
-    }
-    relinka("info", "Fetching .env.example file...");
-    const content = await fetchEnvExampleContent(fallbackEnvExampleURL);
-    if (!content) {
-      relinka("error", "Failed to fetch .env.example content.");
-      return false;
-    }
-    if (!await safeWriteFile(exampleEnvPath, content)) {
-      relinka("error", "Failed to write .env.example file.");
-      return false;
-    }
-    relinka("success", ".env.example file fetched and saved.");
-    return true;
-  } catch {
-    relinka("error", "Failed to ensure .env.example exists.");
-    return false;
-  }
-}
-export async function ensureEnvExists(projectPath) {
-  const { envPath, exampleEnvPath } = getEnvPaths(projectPath);
-  try {
-    if (await fs.pathExists(envPath)) {
-      return true;
-    }
-    const exampleContent = await safeReadFile(exampleEnvPath);
-    if (!exampleContent) {
-      relinka("error", "Failed to read .env.example file.");
-      return false;
-    }
-    if (!await safeWriteFile(envPath, exampleContent)) {
-      relinka("error", "Failed to create .env file.");
-      return false;
-    }
-    relinka("verbose", ".env file created from .env.example provided by the template.");
-    return true;
-  } catch {
-    relinka("error", "Failed to ensure .env exists.");
-    return false;
-  }
-}
-function parseEnvKeys(envContents) {
-  const result = {};
-  const lines = envContents.split("\n").map((l) => l.trim()).filter((l) => !!l && !l.startsWith("#"));
-  for (const line of lines) {
-    const [rawKey, ...rest] = line.split("=");
-    if (!rawKey) continue;
-    const key = rawKey.trim();
-    let rawValue = rest.join("=");
-    rawValue = rawValue.replace(/^["']|["']$/g, "");
-    result[key] = rawValue;
-  }
-  return result;
-}
-export async function getMissingKeys(projectPath) {
-  const { envPath, exampleEnvPath } = getEnvPaths(projectPath);
-  try {
-    const envContent = await safeReadFile(envPath);
-    if (!envContent) {
-      relinka("error", "Failed to read .env file.");
-      return [];
-    }
-    const exampleContent = await safeReadFile(exampleEnvPath);
-    if (!exampleContent) {
-      relinka("error", "Failed to read .env.example file.");
-      return [];
-    }
-    const requiredKeys = await getRequiredKeys(exampleEnvPath);
-    const existingEnvKeys = parseEnvKeys(envContent);
-    const missing = requiredKeys.filter((key) => {
-      const val = existingEnvKeys[key];
-      return !val;
-    });
-    return missing;
-  } catch {
-    relinka("error", "Failed to get missing keys.");
-    return [];
-  }
-}
-async function getRequiredKeys(exampleEnvPath) {
-  const content = await safeReadFile(exampleEnvPath);
-  if (!content) return [];
-  return content.split("\n").map((line) => line.trim()).filter((line) => !!line && !line.startsWith("#")).map((line) => line.split("=")[0]).filter((key) => !!key).map((key) => key.trim());
-}
-export async function copyFromExisting(projectPath, sourcePath) {
-  const { envPath } = getEnvPaths(projectPath);
-  try {
-    let fullEnvPath = sourcePath;
-    const stats = await fs.stat(sourcePath).catch(() => null);
-    if (stats?.isDirectory()) {
-      fullEnvPath = path.join(sourcePath, ".env");
-    }
-    if (!await fs.pathExists(fullEnvPath)) {
-      relinka("error", `Could not find .env file at ${fullEnvPath}`);
-      return false;
-    }
-    await fs.copy(fullEnvPath, envPath);
-    relinka("verbose", "Existing .env file has been copied successfully!");
-    return true;
-  } catch {
-    relinka("error", "Failed to copy existing .env file.");
-    return false;
-  }
-}
-export function getEnvPath(projectPath) {
-  return getEnvPaths(projectPath).envPath;
-}
-export async function fetchEnvExampleContent(urlResource) {
-  try {
-    const response = await ofetch(urlResource);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch .env.example from ${urlResource}`);
-    }
-    const text = await response.text();
-    return typeof text === "string" ? text : null;
-  } catch (error) {
-    relinka(
-      "error",
-      `Error fetching .env.example: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return null;
-  }
-}
-const LAST_ENV_FILE_KEY = "last_env_file";
-async function updateEnvValue(envPath, key, value) {
-  const envContent = await fs.readFile(envPath, "utf8");
-  const envLines = envContent.split("\n");
-  const newLine = `${key}="${value}"`;
-  const lineIndex = envLines.findIndex((line) => {
-    const [existingKey] = line.split("=");
-    return existingKey?.trim() === key;
-  });
-  if (lineIndex !== -1) {
-    envLines[lineIndex] = newLine;
-  } else {
-    envLines.push(newLine);
-  }
-  await fs.writeFile(envPath, `${envLines.join("\n").trim()}
-`);
-}
-function validateKeyValue(value, keyType) {
-  const trimmed = value.trim();
-  switch (keyType) {
-    case "string":
-    case "password":
-    case "database":
-      return true;
-    case "email": {
-      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-      return emailRegex.test(trimmed) ? true : "Please enter a valid email address.";
-    }
-    case "boolean": {
-      const lower = trimmed.toLowerCase();
-      if (lower === "true" || lower === "false") return true;
-      return 'Please enter "true" or "false".';
-    }
-    case "number": {
-      return Number.isNaN(Number(trimmed)) ? "Please enter a valid number." : true;
-    }
-    default:
-      return true;
-  }
-}
-function generateSecureString(length = 64) {
-  const randomBytesArray = new Uint8Array(Math.ceil(length / 2));
-  getRandomValues(randomBytesArray);
-  return Array.from(randomBytesArray).map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, length);
-}
-export async function promptAndSetMissingValues(missingKeys, envPath, maskInput, config, wasEnvCopied = false, isMrse = false, projectPath = "", skipPrompts = false) {
-  if (missingKeys.length === 0 || wasEnvCopied) {
-    relinka(
-      "verbose",
-      wasEnvCopied ? "Using values from copied .env file" : "No missing keys to process."
-    );
-    return;
-  }
-  relinka("verbose", `Processing missing values: ${missingKeys.join(", ")}`);
-  let mrseEnvPath = null;
-  let projectName = "";
-  if (isMrse && projectPath) {
-    projectName = path.basename(projectPath);
-    mrseEnvPath = path.join(projectPath, "mrse", `${projectName}.env`);
-    const mrseEnvExists = await fs.pathExists(mrseEnvPath).catch(() => false);
-    if (skipPrompts && mrseEnvExists) {
-      relinka("info", `Using environment variables from mrse/${projectName}.env`);
-      if (await copyFromExisting(projectPath, mrseEnvPath)) {
-        relinka("success", "Environment variables copied from mrse environment file.");
-        const remainingMissingKeys = await getMissingKeys(projectPath);
-        if (remainingMissingKeys.length > 0) {
-          relinka(
-            "info",
-            `The following keys are still missing in the copied .env file: ${remainingMissingKeys.join(", ")}`
-          );
-          await promptAndSetMissingValues(
-            remainingMissingKeys,
-            envPath,
-            maskInput,
-            config,
-            true,
-            isMrse,
-            projectPath,
-            skipPrompts
-          );
-        }
-        return;
-      }
-    }
-  }
-  const servicesWithMissingKeys = Object.entries(KNOWN_SERVICES).filter(
-    ([, service]) => service.keys.some((k) => missingKeys.includes(k.key))
-  );
-  const selectedServicesMsg = config.envComposerOpenBrowser ? "\u2728 I'll open the service dashboards for you. Remember to come back to the terminal after accessing them!" : "\u2728 I'll show you the dashboard links for your selected services. You can open them in your browser (use Ctrl+Click if your terminal supports it).";
-  const validServices = servicesWithMissingKeys.map(([key, service]) => ({
-    label: service.name,
-    value: key
-  }));
-  if (validServices.length === 0) {
-    relinka("verbose", "No known services require missing keys. Possibly custom keys missing?");
-    return;
-  }
-  let options = validServices;
-  if (isMrse && mrseEnvPath && await fs.pathExists(mrseEnvPath)) {
-    options = [
-      {
-        label: `Get keys from mrse/${projectName}.env`,
-        value: "mrse_env"
-      },
-      ...validServices
-    ];
-  }
-  const selectedServices = await multiselectPrompt({
-    title: "Great! Which services do you want to configure?",
-    content: selectedServicesMsg,
-    defaultValue: options.map((srv) => srv.value),
-    options
-  });
-  if (selectedServices.includes("mrse_env") && mrseEnvPath) {
-    relinka("info", `Using environment variables from mrse/${projectName}.env`);
-    if (await copyFromExisting(projectPath, mrseEnvPath)) {
-      relinka("success", "Environment variables copied from mrse environment file.");
-      const remainingMissingKeys = await getMissingKeys(projectPath);
-      if (remainingMissingKeys.length > 0) {
-        relinka(
-          "info",
-          `The following keys are still missing in the copied .env file: ${remainingMissingKeys.join(", ")}`
-        );
-        const filteredServices = selectedServices.filter((s) => s !== "mrse_env");
-        if (filteredServices.length > 0) {
-          for (const serviceKey of filteredServices) {
-            await processService(serviceKey, missingKeys, envPath, maskInput, config);
-          }
-        }
-      }
-      return;
-    }
-  }
-  for (const serviceKey of selectedServices) {
-    if (serviceKey === "skip" || serviceKey === "mrse_env") continue;
-    await processService(serviceKey, missingKeys, envPath, maskInput, config);
-  }
-}
-async function processService(serviceKey, missingKeys, envPath, maskInput, config) {
-  const service = KNOWN_SERVICES[serviceKey];
-  if (!service) return;
-  if (service.dashboardUrl && service.dashboardUrl !== "none") {
-    relinka("verbose", `Opening ${service.name} dashboard...`);
-    if (config.envComposerOpenBrowser) {
-      await open(service.dashboardUrl);
-    } else {
-      relinka("info", `Dashboard link: ${service.dashboardUrl}`);
-    }
-  }
-  for (const keyConfig of service.keys) {
-    if (!missingKeys.includes(keyConfig.key)) {
-      continue;
-    }
-    if (keyConfig.optional) {
-      const displayValue = maskInput && keyConfig.defaultValue ? "[hidden]" : keyConfig.defaultValue === "generate-64-chars" ? "[will generate secure string]" : keyConfig.defaultValue ? `"${keyConfig.defaultValue}"` : "";
-      const shouldFill = await confirmPrompt({
-        title: `Do you want to configure ${keyConfig.key}?${displayValue ? ` (default: ${displayValue})` : ""}`,
-        defaultValue: false
-      });
-      if (!shouldFill) {
-        if (keyConfig.defaultValue) {
-          const value = keyConfig.defaultValue === "generate-64-chars" ? generateSecureString() : keyConfig.defaultValue;
-          await updateEnvValue(envPath, keyConfig.key, value);
-          relinka(
-            "verbose",
-            `Using ${keyConfig.defaultValue === "generate-64-chars" ? "generated" : "default"} value for ${keyConfig.key}${maskInput ? "" : `: ${value}`}`
-          );
-        }
-        continue;
-      }
-    }
-    let isValid = false;
-    let userInput = "";
-    while (!isValid) {
-      const defaultVal = keyConfig.defaultValue === "generate-64-chars" ? generateSecureString() : keyConfig.defaultValue;
-      userInput = await inputPrompt({
-        title: `Enter value for ${keyConfig.key}:`,
-        placeholder: defaultVal ? `Press Enter to use default: ${maskInput ? "[hidden]" : defaultVal}` : "Paste your value here...",
-        defaultValue: defaultVal ?? "",
-        mode: maskInput ? "password" : "plain",
-        ...keyConfig.instruction && {
-          content: keyConfig.instruction,
-          contentColor: "yellowBright"
-        },
-        ...service.dashboardUrl && service.dashboardUrl !== "none" && {
-          hint: `Visit ${service.dashboardUrl} to get your key`
-        }
-      });
-      if (!userInput.trim() && keyConfig.defaultValue) {
-        userInput = keyConfig.defaultValue;
-      }
-      const validationResult = validateKeyValue(userInput, keyConfig.type);
-      if (validationResult === true) {
-        isValid = true;
-      } else {
-        relinka("warn", validationResult);
-      }
-    }
-    const rawValue = userInput.startsWith(`${keyConfig.key}=`) ? userInput.substring(userInput.indexOf("=") + 1) : userInput;
-    const cleanValue = rawValue.trim().replace(/^['"](.*)['"]$/, "$1");
-    await updateEnvValue(envPath, keyConfig.key, cleanValue);
-  }
-}
-export async function saveLastEnvFilePath(envPath) {
-  try {
-    const encryptedPath = await encrypt(envPath);
-    await db.insert(userDataTable).values({
-      key: LAST_ENV_FILE_KEY,
-      value: encryptedPath
-    }).onConflictDoUpdate({
-      target: userDataTable.key,
-      set: { value: encryptedPath }
-    });
-    relinka("success", "Environment file path saved securely. You can use it later.");
-  } catch (error) {
-    relinka(
-      "error",
-      "Failed to save env file path:",
-      error instanceof Error ? error.message : String(error)
-    );
-  }
-}
-export async function getLastEnvFilePath() {
-  try {
-    const result = await db.select().from(userDataTable).where(eq(userDataTable.key, LAST_ENV_FILE_KEY)).get();
-    if (result?.value) {
-      return await decrypt(result.value);
-    }
-    return null;
-  } catch (error) {
-    relinka(
-      "error",
-      "Failed to get last env file path:",
-      error instanceof Error ? error.message : String(error)
-    );
-    return null;
-  }
-}

package/bin/impl/init/use-template/cp-modules/compose-env-file/cef-keys.d.ts

@@ -1,17 +0,0 @@
-export type KeyType = "string" | "email" | "password" | "number" | "boolean" | "database";
-export type KeyVar = "NEXT_PUBLIC_APP_URL" | "DATABASE_URL" | "AUTH_SECRET" | "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY" | "CLERK_SECRET_KEY" | "CLERK_ENCRYPTION_KEY" | "UPLOADTHING_TOKEN" | "UPLOADTHING_SECRET" | "RESEND_API_KEY" | "EMAIL_FROM_ADDRESS" | "NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY" | "STRIPE_API_KEY" | "STRIPE_WEBHOOK_SECRET" | "STRIPE_PRO_MONTHLY_PRICE_ID";
-export type DefaultValue = "http://localhost:3000" | "onboarding@resend.dev" | "pk_test_" | "postgresql://postgres:postgres@localhost:5432/myapp" | "price_" | "re_" | "generate-64-chars" | "replace-me-with-token-from-dashboard" | "sk_live_" | "sk_test_" | "ut_app_" | "whsec_";
-export interface ServiceKey {
-    key: KeyVar;
-    type: KeyType;
-    instruction: string;
-    defaultValue: DefaultValue;
-    optional?: boolean;
-}
-export type DashboardUrl = "none" | "https://clerk.com" | "https://neon.tech" | "https://dashboard.stripe.com" | "https://uploadthing.com/dashboard" | "https://resend.com/api-keys" | "https://dashboard.stripe.com/test/apikeys";
-export interface KnownService {
-    name: string;
-    dashboardUrl: DashboardUrl;
-    keys: ServiceKey[];
-}
-export declare const KNOWN_SERVICES: Record<string, KnownService>;