@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/git.js

@@ -0,0 +1,313 @@
+import path from "@reliverse/pathkit";
+import { re } from "@reliverse/relico";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { deleteLastLine, inputPrompt, selectPrompt } from "@reliverse/rempts";
+import { simpleGit } from "simple-git";
+import { cliName } from "../../../../config/constants.js";
+import { getEffectiveDir } from "../../../../utils/getEffectiveDir.js";
+import { cd, pwd } from "../../../../utils/terminalHelpers.js";
+import { checkGithubRepoOwnership, createGithubRepo } from "./github.js";
+import { isDirHasGit } from "./utils-git-github.js";
+import { handleExistingRepo } from "./utils-repo-exists.js";
+async function validateProjectPath(effectiveDir) {
+  const exists = await fs.pathExists(effectiveDir);
+  if (!exists) {
+    relinka("error", `Project directory does not exist: ${effectiveDir}`);
+  }
+  return exists;
+}
+async function removeGitDir(effectiveDir) {
+  const gitDir = path.join(effectiveDir, ".git");
+  try {
+    await fs.remove(gitDir);
+    relinka("verbose", "Removed existing .git directory");
+    return true;
+  } catch (error) {
+    relinka(
+      "error",
+      "Failed to remove existing .git directory:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return false;
+  }
+}
+export async function initializeGitRepo(git, alreadyGit, config, isTemplateDownload) {
+  if (isTemplateDownload) {
+    relinka("verbose", "Skipping git initialization for template download");
+    return;
+  }
+  if (!alreadyGit) {
+    await git.init();
+    deleteLastLine();
+    relinka("success", "Git repository initialized");
+    const branchName = config.repoBranch && config.repoBranch !== "main" ? config.repoBranch : "main";
+    try {
+      await git.raw(["branch", "-M", branchName]);
+    } catch (error) {
+      relinka(
+        "warn",
+        "Failed to rename default branch:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  } else {
+    relinka("info", "Using existing git repository");
+  }
+}
+async function createGitCommit(git, effectiveDir, alreadyGit, isTemplateDownload, message) {
+  if (isTemplateDownload) {
+    relinka("verbose", "Skipping commit creation for template download");
+    return;
+  }
+  const status = await git.status();
+  if (status.files.length === 0 && !alreadyGit) {
+    relinka("info", "No files to commit. Creating an empty commit");
+    await fs.writeFile(path.join(effectiveDir, ".gitkeep"), "");
+    await git.add(".gitkeep");
+    await git.commit(message ?? `Initial commit by ${cliName}`);
+    relinka("success", "Created empty initial commit");
+  } else if (status.files.length > 0) {
+    await git.add(".");
+    await git.commit(
+      message ?? (alreadyGit ? `Update by ${cliName}` : `Initial commit by ${cliName}`)
+    );
+    relinka("success", alreadyGit ? "Changes committed" : "Initial commit created");
+  } else {
+    relinka("info", "No changes to commit in existing repository");
+  }
+}
+export async function initGitDir(params) {
+  if (params.isTemplateDownload) {
+    relinka("verbose", "Skipping git initialization for template download");
+    return true;
+  }
+  const effectiveDir = getEffectiveDir(params);
+  try {
+    if (!await validateProjectPath(effectiveDir)) {
+      return false;
+    }
+    const alreadyGit = await isDirHasGit(
+      params.cwd,
+      params.isDev,
+      params.projectName,
+      params.projectPath
+    );
+    if (alreadyGit && params.allowReInit) {
+      deleteLastLine();
+      relinka("verbose", "Reinitializing existing git repository...");
+      if (!await removeGitDir(effectiveDir)) return false;
+      const git2 = simpleGit({ baseDir: effectiveDir });
+      await initializeGitRepo(git2, false, params.config, params.isTemplateDownload);
+      if (params.createCommit) {
+        await createGitCommit(git2, effectiveDir, false, params.isTemplateDownload);
+      }
+      return true;
+    }
+    const git = simpleGit({ baseDir: effectiveDir });
+    await initializeGitRepo(git, alreadyGit, params.config, params.isTemplateDownload);
+    if (params.createCommit) {
+      await createGitCommit(git, effectiveDir, alreadyGit, params.isTemplateDownload);
+    }
+    return true;
+  } catch (error) {
+    const alreadyGit = await isDirHasGit(
+      params.cwd,
+      params.isDev,
+      params.projectName,
+      params.projectPath
+    );
+    relinka(
+      "error",
+      `Failed to ${alreadyGit ? "update" : "initialize"} git: ${error instanceof Error ? error.message : String(error)}`
+    );
+    relinka(
+      "info",
+      `You can ${alreadyGit ? "commit changes" : "initialize git"} manually:
+cd ${effectiveDir}
+${alreadyGit ? 'git add .\ngit commit -m "Update"' : 'git init\ngit add .\ngit commit -m "Initial commit"'}`
+    );
+    return false;
+  }
+}
+export async function createCommit(params) {
+  if (params.isTemplateDownload) {
+    relinka("verbose", "Skipping commit creation for template download");
+    return true;
+  }
+  const effectiveDir = getEffectiveDir(params);
+  try {
+    if (!await validateProjectPath(effectiveDir)) return false;
+    const alreadyGit = await isDirHasGit(
+      params.cwd,
+      params.isDev,
+      params.projectName,
+      params.projectPath
+    );
+    const git = simpleGit({ baseDir: effectiveDir });
+    await initializeGitRepo(git, alreadyGit, params.config, params.isTemplateDownload);
+    await createGitCommit(git, effectiveDir, alreadyGit, params.isTemplateDownload, params.message);
+    return true;
+  } catch (error) {
+    const alreadyGit = await isDirHasGit(
+      params.cwd,
+      params.isDev,
+      params.projectName,
+      params.projectPath
+    );
+    relinka(
+      "error",
+      `Failed to ${alreadyGit ? "create commit" : "initialize"} git: ${error instanceof Error ? error.message : String(error)}`
+    );
+    relinka(
+      "info",
+      `You can ${alreadyGit ? "commit changes" : "initialize git"} manually:
+cd ${effectiveDir}
+${alreadyGit ? 'git add .\ngit commit -m "Update"' : 'git init\ngit add .\ngit commit -m "Initial commit"'}`
+    );
+    return false;
+  }
+}
+async function isRepoOwner(githubUsername, repoName, githubToken, githubInstance) {
+  if (!githubToken) {
+    relinka("error", "GitHub token not found in rse's memory");
+    return false;
+  }
+  try {
+    const { isOwner } = await checkGithubRepoOwnership(githubInstance, githubUsername, repoName);
+    return isOwner;
+  } catch (error) {
+    relinka(
+      "error",
+      "Error checking repository ownership:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return false;
+  }
+}
+export async function handleGithubRepo(params) {
+  if (params.isTemplateDownload) {
+    relinka("verbose", "Skipping GitHub repository handling for template download");
+    return true;
+  }
+  const effectiveDir = getEffectiveDir(params);
+  if (!params.memory || !params.githubUsername || !params.githubToken) {
+    relinka("error", "Something went wrong. Please notify CLI developers.");
+    return false;
+  }
+  const repoExists = await isRepoOwner(
+    params.githubUsername,
+    params.projectName,
+    params.githubToken,
+    params.githubInstance
+  );
+  if (!repoExists) {
+    return await createGithubRepo(
+      params.githubInstance,
+      params.projectName,
+      params.githubUsername,
+      effectiveDir,
+      params.isDev,
+      params.cwd,
+      params.config,
+      params.isTemplateDownload
+    );
+  } else {
+    if (params.isDev) {
+      await cd(effectiveDir);
+      pwd();
+    }
+    let choice = "commit";
+    const alreadyExistsDecision = params.config.existingRepoBehavior;
+    if (params.skipPrompts) {
+      switch (alreadyExistsDecision) {
+        case "autoYes":
+          choice = "commit";
+          break;
+        case "autoYesSkipCommit":
+          choice = "skip";
+          break;
+        case "autoNo":
+          choice = "new";
+          break;
+      }
+    } else {
+      choice = await selectPrompt({
+        title: `Repository ${params.githubUsername}/${params.projectName} already exists and you own it. What would you like to do?`,
+        content: "Note: A commit will be created and pushed only if there are uncommitted changes.",
+        options: [
+          {
+            value: "commit",
+            label: `${re.greenBright("\u2705 Recommended")} Use existing repository and create+push new commit`
+          },
+          {
+            value: "skip",
+            label: "Use existing repository, but skip creating a commit"
+          },
+          {
+            value: "new",
+            label: "Initialize a brand-new GitHub repository with a different name"
+          }
+        ],
+        defaultValue: "commit"
+      });
+    }
+    if (choice === "commit" || choice === "skip") {
+      await handleExistingRepo(params, choice === "commit", params.isDev);
+    } else if (choice === "new") {
+      const newName = await inputPrompt({
+        title: "Enter a new repository name:",
+        validate: (value) => {
+          const trimmed = value.trim();
+          if (!trimmed) return "Repository name is required";
+          if (!/^[a-zA-Z0-9-_]+$/.test(trimmed)) return "Invalid repository name format";
+          return true;
+        }
+      });
+      if (!newName || typeof newName !== "string") {
+        relinka("error", "Invalid repository name provided");
+        return false;
+      }
+      return await createGithubRepo(
+        params.githubInstance,
+        newName,
+        params.githubUsername,
+        effectiveDir,
+        params.isDev,
+        params.cwd,
+        params.config,
+        params.isTemplateDownload
+      );
+    }
+    return true;
+  }
+}
+export async function pushGitCommits(params) {
+  const effectiveDir = getEffectiveDir(params);
+  try {
+    if (!await isDirHasGit(params.cwd, params.isDev, params.projectName, params.projectPath)) {
+      relinka("error", "Not a git repository. Please initialize git first.");
+      return false;
+    }
+    const git = simpleGit({ baseDir: effectiveDir });
+    const currentBranch = (await git.branch()).current;
+    if (!currentBranch) {
+      relinka("error", "No current branch found.");
+      return false;
+    }
+    const status = await git.status();
+    if (status.ahead === 0) {
+      relinka("info", "No commits to push.");
+      return true;
+    }
+    await git.push("origin", currentBranch);
+    relinka("success", `Pushed ${status.ahead} commit(s) to origin/${currentBranch}`);
+    return true;
+  } catch (error) {
+    relinka(
+      "error",
+      `Failed to push commits: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+}

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/github.d.ts

@@ -0,0 +1,8 @@
+import type { RseConfig } from "../../../../types/mod.js";
+import { type InstanceGithub } from "../../../../utils/instanceGithub.js";
+export declare function checkGithubRepoOwnership(githubInstance: InstanceGithub, owner: string, repo: string): Promise<{
+    exists: boolean;
+    isOwner: boolean;
+    defaultBranch?: string;
+}>;
+export declare function createGithubRepo(githubInstance: InstanceGithub, repoName: string, repoOwner: string, projectPath: string, isDev: boolean, cwd: string, config: RseConfig, isTemplateDownload: boolean): Promise<boolean>;

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/github.js

@@ -0,0 +1,113 @@
+import { RequestError } from "@octokit/request-error";
+import { relinka } from "@reliverse/relinka";
+import { selectPrompt } from "@reliverse/rempts";
+import { UNKNOWN_VALUE } from "../../../../config/constants.js";
+import { cd } from "../../../../utils/terminalHelpers.js";
+import { initGitDir } from "./git.js";
+import { setupGitRemote } from "./utils-git-github.js";
+export async function checkGithubRepoOwnership(githubInstance, owner, repo) {
+  try {
+    const { data: repository } = await githubInstance.rest.repos.get({
+      owner,
+      repo
+    });
+    return {
+      exists: true,
+      isOwner: repository.permissions?.admin ?? false,
+      defaultBranch: repository.default_branch
+    };
+  } catch (error) {
+    if (error instanceof RequestError) {
+      if (error.status === 404) {
+        return { exists: false, isOwner: false };
+      }
+      if (error.status === 403) {
+        throw new Error("GitHub API rate limit exceeded");
+      }
+      if (error.status === 401) {
+        throw new Error("Invalid GitHub token");
+      }
+    }
+    throw error;
+  }
+}
+export async function createGithubRepo(githubInstance, repoName, repoOwner, projectPath, isDev, cwd, config, isTemplateDownload) {
+  if (isTemplateDownload) {
+    relinka("verbose", "Skipping createGithubRepo since it's a template download");
+    return true;
+  }
+  try {
+    await cd(projectPath);
+    relinka("verbose", "[C] initGitDir");
+    await initGitDir({
+      cwd,
+      isDev,
+      projectPath,
+      projectName: repoName,
+      allowReInit: true,
+      createCommit: true,
+      config,
+      isTemplateDownload
+    });
+    let privacyAction = config.repoPrivacy;
+    if (privacyAction === UNKNOWN_VALUE) {
+      const selectedPrivacyAction = await selectPrompt({
+        title: "Choose repository privacy setting",
+        defaultValue: "public",
+        options: [
+          {
+            label: "Public repository",
+            value: "public",
+            hint: "Anyone can see the repository (recommended for open source)"
+          },
+          {
+            label: "Private repository",
+            value: "private",
+            hint: "Only you and collaborators can see the repository"
+          }
+        ]
+      });
+      privacyAction = selectedPrivacyAction;
+    }
+    relinka("verbose", "Creating repository...");
+    try {
+      await githubInstance.rest.repos.createForAuthenticatedUser({
+        name: repoName,
+        private: privacyAction === "private",
+        auto_init: false
+      });
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("already exists")) {
+        relinka("error", `Repository '${repoName}' already exists on GitHub`);
+        return false;
+      }
+      throw error;
+    }
+    const remoteUrl = `https://github.com/${repoOwner}/${repoName}.git`;
+    relinka("verbose", "Setting up Git remote and pushing initial commit...");
+    return await setupGitRemote(cwd, isDev, repoName, projectPath, remoteUrl, "origin");
+  } catch (error) {
+    if (error instanceof RequestError) {
+      if (error.status === 401 || error.status === 403) {
+        relinka(
+          "error",
+          "GitHub token is invalid or lacks necessary permissions. Ensure your token has the 'repo' scope."
+        );
+      } else if (error.status === 422) {
+        relinka(
+          "error",
+          "Invalid repository name or repository already exists and you don't have access to it."
+        );
+      } else if (error.message?.includes("rate limit")) {
+        relinka("error", "GitHub API rate limit exceeded. Please try again later.");
+      } else if (error.message?.includes("network")) {
+        relinka("error", "Network error occurred. Please check your internet connection.");
+      } else {
+        relinka("error", "GitHub operation failed:", error.message);
+      }
+    } else {
+      relinka("error", "An unexpected error occurred:", error?.message ?? String(error));
+    }
+    return false;
+  }
+}

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/helpers/domainHelpers.d.ts

@@ -0,0 +1 @@
+export declare function isSpecialDomain(d: string): boolean;

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/helpers/domainHelpers.js

@@ -0,0 +1,25 @@
+import { rseOrgBase } from "../../../../../config/constants.js";
+const specialDomains = [
+  // Vercel domains
+  ".vercel.app",
+  // Local development
+  "localhost",
+  ".local",
+  ".test",
+  // Example/placeholder domains
+  "example.com",
+  // Project specific domains
+  `.${rseOrgBase}`,
+  ".relivator.com",
+  ".bleverse.com"
+];
+export function isSpecialDomain(d) {
+  return specialDomains.some(
+    (special) => (
+      // Exact match
+      d === special || // Ends with for TLD/subdomain patterns
+      special.startsWith(".") && d.endsWith(special) || // Full domain match
+      d.toLowerCase() === special.toLowerCase()
+    )
+  );
+}

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/helpers/handlePkgJsonScripts.d.ts

@@ -0,0 +1 @@
+export declare function ensureDbInitialized(hasDbPush: boolean, shouldRunDbPush: boolean, shouldInstallDeps: boolean, projectPath: string): Promise<"success" | "skip" | "cancel">;

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/helpers/handlePkgJsonScripts.js

@@ -0,0 +1,52 @@
+import { relinka } from "@reliverse/relinka";
+import { selectPrompt } from "@reliverse/rempts";
+import { execa } from "execa";
+import { installDependencies } from "nypm";
+export async function ensureDbInitialized(hasDbPush, shouldRunDbPush, shouldInstallDeps, projectPath) {
+  if (!hasDbPush || shouldRunDbPush) {
+    return "success";
+  }
+  const choice = await selectPrompt({
+    title: "You project has `db:push` script, it is recommended to run it before deploying. Without initializing, your production build may crash.\n\u2705 It is safe to skip if you have already run it before.",
+    content: !shouldInstallDeps ? "This requires dependencies to be installed." : "",
+    options: [
+      {
+        label: !shouldInstallDeps ? "Install dependencies, run `db:push`, and deploy" : "Run `db:push` to initialize database",
+        value: "yes"
+      },
+      {
+        label: "Deploy without running `db:push`",
+        value: "skip",
+        hint: "not recommended"
+      },
+      { label: "Cancel deployment process", value: "cancel" }
+    ],
+    defaultValue: "yes"
+  });
+  if (choice === "cancel") {
+    return "cancel";
+  }
+  if (choice === "skip") {
+    relinka("warn", "Proceeding without running `db:push`...");
+    return "skip";
+  }
+  try {
+    if (!shouldInstallDeps) {
+      await installDependencies({
+        cwd: projectPath
+      });
+    }
+    await execa("bun", ["db:push"], {
+      cwd: projectPath,
+      stdio: "inherit"
+    });
+    return "success";
+  } catch (error) {
+    relinka(
+      "error",
+      "Error running `bun db:push`:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return "cancel";
+  }
+}

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/helpers/promptForDomain.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Prompts for and validates a custom domain
+ */
+export declare function promptForDomain(projectName: string): Promise<string>;

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/helpers/promptForDomain.js

@@ -0,0 +1,39 @@
+import { inputPrompt, selectPrompt } from "@reliverse/rempts";
+import { DEFAULT_DOMAIN } from "../../../../../config/constants.js";
+import { experimental, recommended } from "../../../../../utils/badgeNotifiers.js";
+function validateDomain(domain) {
+  if (!domain) return "Domain is required";
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9-_.]+\.[a-zA-Z]{2,}$/.test(domain)) {
+    return "Invalid domain format";
+  }
+  return true;
+}
+export async function promptForDomain(projectName) {
+  const defaultDomain = `${projectName}.vercel.app`;
+  const useDomain = await selectPrompt({
+    title: "Would you like to use a custom domain?",
+    content: "You can add a custom domain later in the Vercel dashboard.",
+    options: [
+      {
+        label: `No, use default Vercel domain only ${recommended}`,
+        value: "default",
+        hint: defaultDomain
+      },
+      {
+        label: `Yes, configure custom domain ${experimental}`,
+        value: "custom",
+        hint: "The default domain will still be generated"
+      }
+    ],
+    defaultValue: "default"
+  });
+  if (useDomain === "default") {
+    return defaultDomain;
+  }
+  const domain = await inputPrompt({
+    title: "Enter your custom domain:",
+    content: DEFAULT_DOMAIN,
+    validate: validateDomain
+  });
+  return domain || defaultDomain;
+}

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/utils-git-github.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if the given directory is a git repository
+ */
+export declare function isDirHasGit(cwd: string, isDev: boolean, projectName: string, projectPath: string): Promise<boolean>;
+/**
+ * Sets up a remote for an existing local git repository and pushes the initial commit
+ */
+export declare function setupGitRemote(cwd: string, isDev: boolean, projectName: string, projectPath: string, remoteUrl: string, remoteName?: string): Promise<boolean>;

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/utils-git-github.js

@@ -0,0 +1,75 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { simpleGit } from "simple-git";
+export async function isDirHasGit(cwd, isDev, projectName, projectPath) {
+  const effectiveDir = isDev ? path.join(cwd, "tests-runtime", projectName) : projectPath;
+  try {
+    if (!await fs.pathExists(effectiveDir)) {
+      relinka("error", `Directory does not exist: ${effectiveDir}`);
+      return false;
+    }
+    const gitDir = path.join(effectiveDir, ".git");
+    if (!await fs.pathExists(gitDir)) {
+      return false;
+    }
+    const git = simpleGit({ baseDir: effectiveDir });
+    return await git.checkIsRepo();
+  } catch (error) {
+    if (!(error instanceof Error && error.message.includes("not a git repository"))) {
+      relinka(
+        "error",
+        "Error checking git repository:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    return false;
+  }
+}
+export async function setupGitRemote(cwd, isDev, projectName, projectPath, remoteUrl, remoteName = "origin") {
+  const effectiveDir = isDev ? path.join(cwd, "tests-runtime", projectName) : projectPath;
+  try {
+    if (!await fs.pathExists(effectiveDir)) {
+      relinka("error", `Directory does not exist: ${effectiveDir}`);
+      return false;
+    }
+    if (!await isDirHasGit(cwd, isDev, projectName, projectPath)) {
+      relinka(
+        "error",
+        "Not a git repository, git should be initialized before setupGitRemote. Something went wrong. Please notify developers."
+      );
+      return false;
+    }
+    const git = simpleGit({ baseDir: effectiveDir });
+    const remotes = await git.getRemotes();
+    if (!remotes.find((remote) => remote.name === remoteName)) {
+      await git.addRemote(remoteName, remoteUrl);
+      relinka("verbose", `Remote '${remoteName}' added successfully.`);
+    } else {
+      const remoteGetUrl = await git.remote(["get-url", remoteName]);
+      const existingUrl = remoteGetUrl ? remoteGetUrl.trim() : "";
+      if (existingUrl !== remoteUrl) {
+        await git.remote(["set-url", remoteName, remoteUrl]);
+        relinka("info", `Updated ${remoteName} remote URL to ${remoteUrl}`);
+      } else {
+        relinka("info", `Remote '${remoteName}' already exists with correct URL.`);
+      }
+    }
+    await git.push(remoteName, "main", ["--set-upstream"]);
+    relinka("success", "Initial commit pushed to remote repository:", remoteUrl);
+    return true;
+  } catch (error) {
+    relinka(
+      "error",
+      `Failed to setup git remote: ${error instanceof Error ? error.message : String(error)}`
+    );
+    relinka(
+      "info",
+      `You can setup the remote manually:
+cd ${effectiveDir}
+git remote add ${remoteName} ${remoteUrl}
+git push -u ${remoteName} main`
+    );
+    return false;
+  }
+}

package/bin/app/init/use-template/cp-modules/git-deploy-prompts/utils-private-repo.d.ts

@@ -0,0 +1,12 @@
+import type { ReliverseMemory } from "../../../../utils/schemaMemory.js";
+/**
+ * Clones a repository to a temporary directory and copies specified files
+ */
+export declare function archiveExistingRepoContent(repoUrl: string, projectPath: string): Promise<{
+    success: boolean;
+    externalRseConfig?: string;
+}>;
+export declare function handleExistingRepoContent(memory: ReliverseMemory, repoOwner: string, repoName: string, projectPath: string): Promise<{
+    success: boolean;
+    externalRseConfig?: string;
+}>;