@reliverse/dler 1.7.92 → 1.7.94

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

@@ -0,0 +1,165 @@
+import path from "@reliverse/pathkit";
+import fs, { ensuredir, setHiddenAttribute } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt } from "@reliverse/rempts";
+import { simpleGit } from "simple-git";
+import tar from "tar-stream";
+import { promisify } from "util";
+import { gzip } from "zlib";
+import { cliConfigJsonc, cliConfigJsoncTmp, cliHomeTmp } from "../../../../config/constants.js";
+const gzipAsync = promisify(gzip);
+async function createArchive(files) {
+  const pack = tar.pack();
+  for (const file of files) {
+    pack.entry({ name: file.name }, file.data);
+  }
+  pack.finalize();
+  const chunks = [];
+  for await (const chunk of pack) {
+    chunks.push(chunk);
+  }
+  const tarBuffer = Buffer.concat(chunks);
+  return gzipAsync(tarBuffer);
+}
+export async function archiveExistingRepoContent(repoUrl, projectPath) {
+  const tempDir = path.join(cliHomeTmp, Date.now().toString());
+  try {
+    await ensuredir(tempDir);
+    const git = simpleGit();
+    await git.clone(repoUrl, tempDir);
+    const shouldArchive = await confirmPrompt({
+      title: "Would you like to create an archive of the existing repository content?",
+      content: "In the future, you will be able to run `rse cli` to use merge operations on the project's old and new content. The term `cluster` is used as the name for the old content.",
+      defaultValue: false
+    });
+    if (shouldArchive) {
+      const fileInputs = [];
+      const tempFiles = await fs.readdir(tempDir);
+      for (const file of tempFiles) {
+        if (file !== ".git") {
+          const filePath = path.join(tempDir, file);
+          const stats = await fs.stat(filePath);
+          if (stats.isFile()) {
+            const data = await fs.readFile(filePath);
+            fileInputs.push({
+              name: file,
+              data: Buffer.isBuffer(data) ? data : Buffer.from(data)
+            });
+          } else if (stats.isDirectory()) {
+            const dirFiles = await fs.readdir(filePath, {
+              recursive: true
+            });
+            for (const dirFile of dirFiles) {
+              const fullPath = path.join(tempDir, file, dirFile);
+              if ((await fs.stat(fullPath)).isFile()) {
+                const data = await fs.readFile(fullPath);
+                fileInputs.push({
+                  name: `${file}/${dirFile}`,
+                  data: Buffer.isBuffer(data) ? data : Buffer.from(data)
+                });
+              }
+            }
+          }
+        }
+      }
+      if (fileInputs.length > 0) {
+        const archiveName = "cluster.tar.gz";
+        const archivePath = path.join(projectPath, archiveName);
+        const tarData = await createArchive(fileInputs);
+        await fs.writeFile(archivePath, tarData);
+        relinka("info", `Created archive of repository content at ${archiveName}`);
+      }
+    }
+    const gitDir = path.join(tempDir, ".git");
+    if (await fs.pathExists(gitDir)) {
+      const targetGitDir = path.join(projectPath, ".git");
+      if (await fs.pathExists(targetGitDir)) {
+        await fs.remove(targetGitDir);
+        relinka("verbose", "Removed existing .git directory");
+      }
+      await fs.copy(gitDir, path.join(projectPath, ".git"), {
+        preserveTimestamps: true,
+        dereference: false,
+        errorOnExist: false
+      });
+      const gitFolderPath = path.join(projectPath, ".git");
+      await setHiddenAttribute(gitFolderPath);
+      relinka("verbose", "Copied .git folder from existing repository");
+    } else {
+      throw new Error("Required .git folder not found");
+    }
+    const filesToCopy = [
+      { name: "README.md", required: false },
+      { alternatives: ["LICENSE", "LICENSE.md"], required: false },
+      {
+        name: cliConfigJsonc,
+        required: false,
+        targetName: cliConfigJsoncTmp,
+        hidden: true
+      }
+    ];
+    let externalrseth;
+    for (const file of filesToCopy) {
+      if (file.name) {
+        const sourcePath = path.join(tempDir, file.name);
+        if (await fs.pathExists(sourcePath)) {
+          const targetPath = path.join(projectPath, file.targetName ?? file.name);
+          await fs.copy(sourcePath, targetPath);
+          if (!file.hidden) {
+            relinka("info", `Copied ${file.name} from existing repository`);
+          }
+          if (file.name === cliConfigJsonc) {
+            externalrseth = targetPath;
+          }
+        }
+      } else if (file.alternatives) {
+        for (const name of file.alternatives) {
+          const filePath = path.join(tempDir, name);
+          if (await fs.pathExists(filePath)) {
+            await fs.copy(filePath, path.join(projectPath, name));
+            relinka("info", `Copied ${name} from existing repository`);
+            break;
+          }
+        }
+      }
+    }
+    return {
+      success: true,
+      ...externalrseth && { externalRseConfig: externalrseth }
+    };
+  } catch (error) {
+    relinka(
+      "error",
+      "Failed to clone repository:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return { success: false };
+  } finally {
+    try {
+      await fs.remove(tempDir);
+    } catch (error) {
+      relinka("warn", "Failed to cleanup temporary directory:", String(error));
+    }
+  }
+}
+export async function handleExistingRepoContent(memory, repoOwner, repoName, projectPath) {
+  try {
+    const repoUrl = `https://oauth2:${memory.githubKey}@github.com/${repoOwner}/${repoName}.git`;
+    const { success, externalRseConfig } = await archiveExistingRepoContent(repoUrl, projectPath);
+    if (!success) {
+      throw new Error("Failed to retrieve repository git data");
+    }
+    relinka("success", "Retrieved repository git directory data");
+    return {
+      success: true,
+      ...externalRseConfig && { externalRseConfig }
+    };
+  } catch (error) {
+    relinka(
+      "error",
+      "Failed to set up existing repository:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return { success: false };
+  }
+}

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

@@ -0,0 +1,9 @@
+import type { GitModParams, RseConfig } from "../../../../types/mod.js";
+import type { RepoOption } from "../../../../utils/projectRepository.js";
+import type { ReliverseMemory } from "../../../../utils/schemaMemory.js";
+export declare function handleExistingRepo(params: GitModParams & {
+    memory: ReliverseMemory;
+    config: RseConfig;
+    githubUsername: string;
+    selectedTemplate: RepoOption;
+}, shouldCommitAndPush: boolean, isDev: boolean): Promise<boolean>;

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

@@ -0,0 +1,62 @@
+import { relinka } from "@reliverse/relinka";
+import { simpleGit } from "simple-git";
+import { migrateRseConfig } from "../../../../config/cfg-migrate.js";
+import { cliName } from "../../../../config/constants.js";
+import { getEffectiveDir } from "../../../../utils/getEffectiveDir.js";
+import { handleReplacements } from "../../../../utils/replacements/reps-mod.js";
+import { handleExistingRepoContent } from "./utils-private-repo.js";
+export async function handleExistingRepo(params, shouldCommitAndPush, isDev) {
+  const effectiveDir = getEffectiveDir(params);
+  relinka("info", `Using existing repo: ${params.githubUsername}/${params.projectName}`);
+  const { success: repoSuccess, externalRseConfig } = await handleExistingRepoContent(
+    params.memory,
+    params.githubUsername,
+    params.projectName,
+    effectiveDir
+  );
+  if (!repoSuccess) {
+    throw new Error("Failed to handle existing repository content");
+  }
+  if (externalRseConfig) {
+    await migrateRseConfig(externalRseConfig, effectiveDir, isDev);
+  }
+  await handleReplacements(
+    effectiveDir,
+    params.selectedTemplate,
+    "",
+    {
+      ...params.config,
+      projectName: params.projectName,
+      frontendUsername: params.githubUsername,
+      primaryDomain: `${params.projectName}.com`
+    },
+    true,
+    false,
+    false
+  );
+  if (shouldCommitAndPush) {
+    if (!params.memory.githubKey) {
+      throw new Error("GitHub token not found");
+    }
+    const git = simpleGit({ baseDir: effectiveDir });
+    await git.add(".");
+    await git.commit(`Update by ${cliName}`);
+    const latestCommit = await git.log({ maxCount: 1 });
+    if (!latestCommit.latest) {
+      throw new Error("Failed to get latest commit");
+    }
+    try {
+      await git.push("origin", "main");
+      relinka("success", "Created and pushed new commit with changes");
+      return true;
+    } catch (error) {
+      relinka(
+        "error",
+        "Failed to push commit:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return false;
+    }
+  }
+  return true;
+}

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

@@ -0,0 +1,10 @@
+import type { InstanceVercel } from "../../../../../utils/instanceVercel.js";
+import type { EnvVar } from "./vercel-types";
+/**
+ * Gets an environment variable from a Vercel project.
+ */
+export declare function getVercelEnvVar(vercelInstance: InstanceVercel, projectId: string, envVarId: string): Promise<EnvVar | undefined>;
+/**
+ * Handles rate limit errors with retries.
+ */
+export declare function withRateLimit<T>(fn: () => Promise<T>, retries?: number): Promise<T>;

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

@@ -0,0 +1,36 @@
+import { relinka } from "@reliverse/relinka";
+import { projectsGetProjectEnv } from "@vercel/sdk/funcs/projectsGetProjectEnv";
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 5e3;
+export async function getVercelEnvVar(vercelInstance, projectId, envVarId) {
+  try {
+    const res = await projectsGetProjectEnv(vercelInstance, {
+      idOrName: projectId,
+      id: envVarId
+    });
+    if (!res.ok) {
+      throw res.error;
+    }
+    const envVar = res.value;
+    return envVar;
+  } catch (error) {
+    relinka(
+      "error",
+      "Error getting Vercel env var:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return;
+  }
+}
+export async function withRateLimit(fn, retries = MAX_RETRIES) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("rate limit") && retries > 0) {
+      relinka("info", `Rate limit hit, retrying in ${RETRY_DELAY / 1e3}s...`);
+      await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY));
+      return withRateLimit(fn, retries - 1);
+    }
+    throw error;
+  }
+}

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

@@ -0,0 +1,14 @@
+import { type InstanceGithub } from "../../../../../utils/instanceGithub.js";
+/**
+ * Checks whether there is an existing deployment for the given project.
+ *
+ * It validates that the GitHub token exists in memory and that a GitHub
+ * username is provided, then uses Octokit to list deployments.
+ *
+ * @param projectName - The name of the project/repository.
+ * @param githubUsername - The GitHub username (owner).
+ * @param githubToken - The GitHub token.
+ *
+ * @returns True if at least one deployment is found; false otherwise.
+ */
+export declare function checkVercelDeployment(projectName: string, githubUsername: string, githubToken: string, githubInstance: InstanceGithub): Promise<boolean>;

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

@@ -0,0 +1,29 @@
+import { relinka } from "@reliverse/relinka";
+export async function checkVercelDeployment(projectName, githubUsername, githubToken, githubInstance) {
+  relinka("verbose", "Checking for existing deployment...");
+  if (!githubToken) {
+    relinka(
+      "error",
+      "GitHub token not found in rseory. Please restart the CLI and try again. Notify the @reliverse/rsrseers if the problem persists."
+    );
+    return false;
+  }
+  if (!githubUsername || githubUsername.trim() === "") {
+    relinka("error", "GitHub username is missing");
+    return false;
+  }
+  try {
+    const { data: deployments } = await githubInstance.rest.repos.listDeployments({
+      owner: githubUsername,
+      repo: projectName
+    });
+    return deployments.length > 0;
+  } catch (error) {
+    relinka(
+      "error",
+      "Failed to check Vercel deployments:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return false;
+  }
+}

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

@@ -0,0 +1,27 @@
+import type { UpdateProjectRequestBody } from "@vercel/sdk/models/updateprojectop";
+import type { InstanceVercel } from "../../../../../utils/instanceVercel.js";
+/**
+ * Updates a Vercel project with the given configuration
+ * @see https://github.com/vercel/sdk/blob/main/docs/sdks/projects/README.md#updateproject
+ */
+export declare function updateProject(vercelInstance: InstanceVercel, projectId: string, config: UpdateProjectRequestBody, teamId?: string, teamSlug?: string): Promise<void>;
+/**
+ * Enables analytics for the project
+ */
+export declare function enableAnalytics(vercelInstance: InstanceVercel, projectId: string): Promise<void>;
+/**
+ * Configures branch protection settings
+ */
+export declare function configureBranchProtection(vercelInstance: InstanceVercel, projectId: string): Promise<void>;
+/**
+ * Configures resource settings
+ */
+export declare function configureResources(vercelInstance: InstanceVercel, projectId: string): Promise<void>;
+export interface ConfigurationOptions {
+    options: string[];
+    useSharedEnvVars: boolean;
+}
+/**
+ * Gets configuration options from user
+ */
+export declare function getConfigurationOptions(): Promise<ConfigurationOptions>;

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

@@ -0,0 +1,104 @@
+import { relinka } from "@reliverse/relinka";
+import { multiselectPrompt } from "@reliverse/rempts";
+import { projectsUpdateProject } from "@vercel/sdk/funcs/projectsUpdateProject";
+import { experimental } from "../../../../../utils/badgeNotifiers.js";
+import { withRateLimit } from "./vercel-api.js";
+export async function updateProject(vercelInstance, projectId, config, teamId, teamSlug) {
+  try {
+    const res = await withRateLimit(async () => {
+      return await projectsUpdateProject(vercelInstance, {
+        idOrName: projectId,
+        teamId,
+        slug: teamSlug,
+        requestBody: config
+      });
+    });
+    if (!res.ok) {
+      throw res.error;
+    }
+  } catch (error) {
+    relinka(
+      "warn",
+      `Could not update project ${projectId}:`,
+      error instanceof Error ? error.message : String(error)
+    );
+    throw error;
+  }
+}
+export async function enableAnalytics(vercelInstance, projectId) {
+  try {
+    await updateProject(vercelInstance, projectId, {
+      customerSupportCodeVisibility: true
+    });
+    relinka("success", "Analytics enabled successfully");
+  } catch (error) {
+    relinka(
+      "warn",
+      "Could not enable analytics:",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+export async function configureBranchProtection(vercelInstance, projectId) {
+  try {
+    await updateProject(vercelInstance, projectId, {
+      gitForkProtection: true,
+      enablePreviewFeedback: true
+    });
+    relinka("success", "Branch protection configured successfully");
+  } catch (error) {
+    relinka(
+      "warn",
+      "Could not configure branch protection:",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+export async function configureResources(vercelInstance, projectId) {
+  try {
+    await updateProject(vercelInstance, projectId, {
+      serverlessFunctionRegion: "iad1"
+    });
+    relinka("success", "Resource configuration updated successfully");
+  } catch (error) {
+    relinka(
+      "warn",
+      "Could not configure resources:",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+export async function getConfigurationOptions() {
+  const result = await multiselectPrompt({
+    title: "Select Vercel deployment options:",
+    options: [
+      { value: "env", label: "Upload environment variables" },
+      {
+        value: "shared_env",
+        label: `Get Vercel shared env vars ${experimental}`
+      },
+      {
+        value: "analytics",
+        label: `Enable analytics ${experimental}`
+      },
+      {
+        value: "protection",
+        label: `Configure branch protection ${experimental}`
+      },
+      {
+        value: "resources",
+        label: `Configure serverless resources ${experimental}`
+      },
+      {
+        value: "monitoring",
+        label: `Show detailed deployment logs ${experimental}`
+      }
+    ],
+    defaultValue: ["env"]
+  });
+  const selectedOptions = Array.isArray(result) ? result : ["env"];
+  return {
+    options: selectedOptions,
+    useSharedEnvVars: selectedOptions.includes("shared_env")
+  };
+}

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

@@ -0,0 +1,17 @@
+import type { InstanceGithub } from "../../../../../utils/instanceGithub.js";
+import type { InstanceVercel } from "../../../../../utils/instanceVercel.js";
+import type { ReliverseMemory } from "../../../../../utils/schemaMemory.js";
+/**
+ * Creates a new Vercel project.
+ */
+export declare function createVercelProject(projectName: string, projectPath: string, vercelInstance: InstanceVercel): Promise<string>;
+/**
+ * Prepares a new Vercel project creation by:
+ * 1. Retrieving configuration options.
+ * 2. Creating the project in the Vercel registry.
+ * 3. Running additional configuration tasks (analytics, protection and resources).
+ * 4. (Optionally) setting up a custom domain.
+ * 5. Uploading environment variables.
+ * 6. Creating the initial deployment.
+ */
+export declare function prepareVercelProjectCreation(githubInstance: InstanceGithub, vercelInstance: InstanceVercel, vercelToken: string, githubToken: string, skipPrompts: boolean, projectName: string, projectPath: string, domain: string, memory: ReliverseMemory, deployMode: "new" | "update", githubUsername: string): Promise<boolean>;

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

@@ -0,0 +1,129 @@
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt } from "@reliverse/rempts";
+import { projectsAddProjectDomain } from "@vercel/sdk/funcs/projectsAddProjectDomain";
+import { projectsCreateProject } from "@vercel/sdk/funcs/projectsCreateProject";
+import { isSpecialDomain } from "../helpers/domainHelpers.js";
+import { updateReliverseMemory } from "../../../../../utils/reliverseMemory.js";
+import { withRateLimit } from "./vercel-api.js";
+import {
+  configureBranchProtection,
+  configureResources,
+  enableAnalytics,
+  getConfigurationOptions
+} from "./vercel-config.js";
+import { createInitialVercelDeployment } from "./vercel-deploy.js";
+import { addEnvVarsToVercelProject } from "./vercel-env.js";
+import { detectFramework, verifyDomain } from "./vercel-utils.js";
+export async function createVercelProject(projectName, projectPath, vercelInstance) {
+  relinka("info", "Creating new Vercel project...");
+  const framework = await detectFramework(projectPath);
+  const createProjectRes = await withRateLimit(
+    async () => projectsCreateProject(vercelInstance, {
+      requestBody: {
+        name: projectName,
+        framework,
+        gitRepository: {
+          type: "github",
+          repo: projectName
+        }
+      }
+    })
+  );
+  if (!createProjectRes.ok) {
+    throw createProjectRes.error;
+  }
+  const projectId = createProjectRes.value.id;
+  relinka("verbose", `Project created with ID: ${projectId}`);
+  return projectId;
+}
+export async function prepareVercelProjectCreation(githubInstance, vercelInstance, vercelToken, githubToken, skipPrompts, projectName, projectPath, domain, memory, deployMode, githubUsername) {
+  if (!vercelToken) {
+    throw new Error(
+      "Vercel token not found in rse's memory. Please restart the CLI and try again. Notify the @reliverse/rse developers if the problem persists."
+    );
+  }
+  try {
+    const selectedOptions = deployMode === "new" || skipPrompts ? { options: ["env"] } : await getConfigurationOptions();
+    const projectId = await createVercelProject(projectName, projectPath, vercelInstance);
+    if (selectedOptions.options.includes("analytics")) {
+      await enableAnalytics(vercelInstance, projectId);
+    }
+    if (selectedOptions.options.includes("protection")) {
+      await configureBranchProtection(vercelInstance, projectId);
+    }
+    if (selectedOptions.options.includes("resources")) {
+      await configureResources(vercelInstance, projectId);
+    }
+    if (!isSpecialDomain(domain) && domain !== `${projectName}.vercel.app`) {
+      let shouldAddDomain = false;
+      if (!skipPrompts) {
+        shouldAddDomain = await confirmPrompt({
+          title: `Do you want to add ${domain} to your Vercel project?`,
+          content: `If not, a ${projectName}.vercel.app domain will be created automatically. You can always add a custom domain later in the dashboard.`
+        });
+      }
+      if (!shouldAddDomain) {
+        relinka("info", "Skipping custom domain configuration");
+      } else {
+        relinka("info", "Setting up custom domain...");
+        try {
+          const addDomainRes = await projectsAddProjectDomain(vercelInstance, {
+            idOrName: projectName,
+            requestBody: { name: domain }
+          });
+          if (!addDomainRes.ok) {
+            throw addDomainRes.error;
+          }
+          const verified = await verifyDomain(vercelInstance, projectId, domain);
+          if (!verified) {
+            relinka("warn", "Domain not verified. Complete verification in the dashboard.");
+          }
+        } catch (error) {
+          relinka(
+            "warn",
+            "Failed to set up custom domain. You can add it later:",
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+    }
+    if (selectedOptions.options.includes("env")) {
+      await addEnvVarsToVercelProject(vercelInstance, projectName, projectPath, {
+        options: selectedOptions.options,
+        useSharedEnvVars: false
+      });
+    }
+    const deployment = await createInitialVercelDeployment(
+      githubInstance,
+      vercelInstance,
+      projectId,
+      memory,
+      projectName,
+      { framework: await detectFramework(projectPath) },
+      {
+        includes: (option) => selectedOptions.options.includes(option)
+      },
+      githubUsername,
+      githubToken
+    );
+    relinka("success", `Deployment preview URL: https://${deployment.url}`);
+    relinka("verbose", "\u2705 Deployment completed successfully!");
+    return true;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("rate limit")) {
+        relinka("error", "Vercel API rate limit exceeded. Please try again later.");
+      } else if (error.message.includes("network")) {
+        relinka("error", "Network error. Please check your connection.");
+      } else if (error.message.includes("unauthorized")) {
+        relinka("error", "Invalid/expired Vercel token. Please provide a new token.");
+        await updateReliverseMemory({ vercelKey: "" });
+      } else {
+        relinka("error", "Error creating Vercel deployment:", error.message);
+      }
+    } else {
+      relinka("error", "Unexpected error during deployment");
+    }
+    return false;
+  }
+}

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

@@ -0,0 +1,20 @@
+import { type InstanceGithub } from "../../../../../utils/instanceGithub.js";
+import type { InstanceVercel } from "../../../../../utils/instanceVercel.js";
+import type { ReliverseMemory } from "../../../../../utils/schemaMemory.js";
+import type { VercelDeploymentConfig } from "./vercel-types";
+/**
+ * Monitors the deployment logs until the deployment reaches a READY state.
+ */
+export declare function monitorDeployment(vercelInstance: InstanceVercel, deploymentId: string, teamId: string, slug: string, showDetailedLogs?: boolean): Promise<void>;
+/**
+ * Creates the initial Vercel deployment for a project.
+ * This function handles the gitSource information by:
+ * 1. Retrieving the local HEAD commit SHA.
+ * 2. Using Octokit (via the GitHub token) to get the repository's numeric ID.
+ */
+export declare function createInitialVercelDeployment(githubInstance: InstanceGithub, vercelInstance: InstanceVercel, projectId: string, memory: ReliverseMemory, projectName: string, config: VercelDeploymentConfig, selectedOptions: {
+    includes: (option: string) => boolean;
+}, githubUsername: string, githubToken: string): Promise<{
+    url: string;
+    id: string;
+}>;