@reliverse/dler 1.7.153 → 2.0.1

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

@@ -1,168 +0,0 @@
-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 && { externalReliverseConfig: 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, externalReliverseConfig } = 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,
-      ...externalReliverseConfig && { externalReliverseConfig }
-    };
-  } catch (error) {
-    relinka(
-      "error",
-      "Failed to set up existing repository:",
-      error instanceof Error ? error.message : String(error)
-    );
-    return { success: false };
-  }
-}

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

@@ -1,10 +0,0 @@
-import type { ReliverseConfig } from "../../../../schema/mod.js";
-import type { GitModParams } 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: ReliverseConfig;
-    githubUsername: string;
-    selectedTemplate: RepoOption;
-}, shouldCommitAndPush: boolean, isDev: boolean): Promise<boolean>;

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

@@ -1,62 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { simpleGit } from "simple-git";
-import { cliName } from "../../../../config/constants.js";
-import { migrateReliverseConfig } from "../../../../config/migrate.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, externalReliverseConfig } = await handleExistingRepoContent(
-    params.memory,
-    params.githubUsername,
-    params.projectName,
-    effectiveDir
-  );
-  if (!repoSuccess) {
-    throw new Error("Failed to handle existing repository content");
-  }
-  if (externalReliverseConfig) {
-    await migrateReliverseConfig(externalReliverseConfig, 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/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-api.d.ts

@@ -1,10 +0,0 @@
-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/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-api.js

@@ -1,36 +0,0 @@
-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/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-check.d.ts

@@ -1,14 +0,0 @@
-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/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-check.js

@@ -1,29 +0,0 @@
-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/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-config.d.ts

@@ -1,27 +0,0 @@
-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/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-config.js

@@ -1,104 +0,0 @@
-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 () => 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/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-create.d.ts

@@ -1,17 +0,0 @@
-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/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-create.js

@@ -1,129 +0,0 @@
-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 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/impl/init/use-template/cp-modules/git-deploy-prompts/vercel/vercel-deploy.d.ts

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