Add ability to link tryitout deployments on login (#35877)

If someone tries Convex without an account and later decides to create an account, they can run `npx convex login` which will prompt the developer to link their "tryitout" deployments with their new account.

By default, for each "tryitout" deployment, we'll create a new project and make the "tryitout" deployment the local dev deployment for the new project (so it'll have all the same data, but a different name, and it'll appear in dashboard.convex.dev when the user logs in there).

Under the hood, this is
* creating a project
* calling `/local_deployment/start` on big brain to register the deployment as part of the project and get an instance name + admin key
* copy the contents of `tryitout-foo` to `local-sarahs_team-foo`
* update the config file of in `local-sarahs_team-foo`

There's an interactive flow under `npx convex login --link-deployments` if the developer wants to link these one by one -- we prompt this if the developer has more "tryitout" deployments than projects available on their team.

GitOrigin-RevId: 86983bea22755f5636d0f7931964506af4af0021

Author: sshader

npm-packages/convex/src/cli/configure.ts

@@ -247,7 +247,7 @@ export async function _deploymentCredentialsOrConfigure(
           return await ctx.crash({
             exitCode: 0,
             errorType: "fatal",
-            printedMessage: `Run \`npx convex login\` first to link this deployment to your account, and then run \`npx convex dev\` again.`,
+            printedMessage: `Run \`npx convex login --link-deployments\` first to link this deployment to your account, and then run \`npx convex dev\` again.`,
           });
         }
         return await handleChooseProject(
@@ -453,7 +453,7 @@ export async function handleManuallySetUrlAndAdminKey(
   return { url, adminKey };
 }
 
-async function selectProject(
+export async function selectProject(
   ctx: Context,
   chosenConfiguration: ChosenConfiguration,
   cmdOptions: {
@@ -463,6 +463,7 @@ async function selectProject(
     local?: boolean | undefined;
     cloud?: boolean | undefined;
     partitionId?: number;
+    defaultProjectName?: string | undefined;
   },
 ): Promise<{
   teamSlug: string;
@@ -499,6 +500,7 @@ async function selectNewProject(
     cloud?: boolean | undefined;
     local?: boolean | undefined;
     partitionId?: number | undefined;
+    defaultProjectName?: string | undefined;
   },
 ) {
   const { teamSlug: selectedTeam, chosen: didChooseBetweenTeams } =
@@ -508,7 +510,7 @@ async function selectNewProject(
   if (!config.project) {
     projectName = await promptString(ctx, {
       message: "Project name:",
-      default: cwd,
+      default: config.defaultProjectName || cwd,
     });
     choseProjectInteractively = true;
   }
@@ -714,7 +716,7 @@ async function ensureDeploymentProvisioned(
   }
 }
 
-async function updateEnvAndConfigForDeploymentSelection(
+export async function updateEnvAndConfigForDeploymentSelection(
   ctx: Context,
   options: {
     url: string;

npm-packages/convex/src/cli/dashboard.ts

@@ -20,7 +20,8 @@ import {
   DEFAULT_LOCAL_DASHBOARD_API_PORT,
   checkIfDashboardIsRunning,
 } from "./lib/localDeployment/dashboard.js";
-const DASHBOARD_HOST = process.env.CONVEX_PROVISION_HOST
+
+export const DASHBOARD_HOST = process.env.CONVEX_PROVISION_HOST
   ? "http://localhost:6789"
   : "https://dashboard.convex.dev";
 

npm-packages/convex/src/cli/lib/deployment.ts

@@ -32,6 +32,13 @@ export function isTryItOutDeployment(deploymentName: string) {
   return deploymentName.startsWith("tryitout-");
 }
 
+export function removeTryItOutPrefix(deploymentName: string) {
+  if (isTryItOutDeployment(deploymentName)) {
+    return deploymentName.slice("tryitout-".length);
+  }
+  return deploymentName;
+}
+
 export async function writeDeploymentEnvVar(
   ctx: Context,
   deploymentType: DeploymentType,

npm-packages/convex/src/cli/lib/deploymentSelection.ts

@@ -616,7 +616,7 @@ export const deploymentNameAndTypeFromSelection = (
   return null;
 };
 
-const shouldAllowTryItOut = (): boolean => {
+export const shouldAllowTryItOut = (): boolean => {
   // Temporary flag while we build out this flow
   return process.env.CONVEX_TRY_IT_OUT !== undefined;
 };

npm-packages/convex/src/cli/lib/fsUtils.ts

@@ -50,7 +50,7 @@ export function recursivelyDelete(
   }
 }
 
-export async function recusivelyCopy(
+export async function recursivelyCopy(
   ctx: Context,
   nodeFs: NodeFs,
   src: string,
@@ -60,7 +60,7 @@ export async function recusivelyCopy(
   if (st.isDirectory()) {
     nodeFs.mkdir(dest, { recursive: true });
     for (const entry of nodeFs.listDir(src)) {
-      await recusivelyCopy(
+      await recursivelyCopy(
         ctx,
         nodeFs,
         path.join(src, entry.name),

npm-packages/convex/src/cli/lib/localDeployment/download.ts

@@ -20,7 +20,7 @@ import { promisify } from "util";
 import { Readable } from "stream";
 import { TempPath, nodeFs, withTmpDir } from "../../../bundler/fs.js";
 import { components } from "@octokit/openapi-types";
-import { recursivelyDelete, recusivelyCopy } from "../fsUtils.js";
+import { recursivelyDelete, recursivelyCopy } from "../fsUtils.js";
 import { LocalDeploymentError } from "./errors.js";
 import ProgressBar from "progress";
 import path from "path";
@@ -360,7 +360,7 @@ async function _ensureDashboardDownloaded(ctx: Context, version: string) {
     filename: "dashboard.zip",
     nameForLogging: "Convex dashboard",
     onDownloadComplete: async (ctx, unzippedPath) => {
-      await recusivelyCopy(ctx, nodeFs, unzippedPath, outDir);
+      await recursivelyCopy(ctx, nodeFs, unzippedPath, outDir);
       logVerbose(ctx, "Copied into out dir");
     },
   });

npm-packages/convex/src/cli/lib/localDeployment/filePaths.ts

@@ -71,7 +71,7 @@ export function loadDeploymentConfig(
 ): LocalDeploymentConfig | null {
   const dir = deploymentStateDir(deploymentKind, deploymentName);
   const configFile = path.join(dir, "config.json");
-  if (!ctx.fs.stat(dir).isDirectory()) {
+  if (!ctx.fs.exists(dir) || !ctx.fs.stat(dir).isDirectory()) {
     logVerbose(ctx, `Deployment ${deploymentName} not found`);
     return null;
   }

npm-packages/convex/src/cli/lib/localDeployment/tryitout.ts

@@ -4,14 +4,24 @@
 import path from "path";
 import {
   Context,
+  logFinishedStep,
   logMessage,
   logVerbose,
   logWarning,
 } from "../../../bundler/context.js";
 import { promptSearch, promptString, promptYesNo } from "../utils/prompts.js";
-import { bigBrainGenerateTryItOutAdminKey } from "./bigBrain.js";
+import {
+  bigBrainGenerateTryItOutAdminKey,
+  bigBrainPause,
+  bigBrainStart,
+} from "./bigBrain.js";
 import { LocalDeploymentError, printLocalDeploymentOnError } from "./errors.js";
-import { loadDeploymentConfig } from "./filePaths.js";
+import {
+  LocalDeploymentKind,
+  deploymentStateDir,
+  loadDeploymentConfig,
+  saveDeploymentConfig,
+} from "./filePaths.js";
 import { rootDeploymentStateDir } from "./filePaths.js";
 import { LocalDeploymentConfig } from "./filePaths.js";
 import { DeploymentDetails } from "./localDeployment.js";
@@ -26,8 +36,12 @@ import {
 } from "./utils.js";
 import { handleDashboard } from "./dashboard.js";
 import crypto from "crypto";
+import { recursivelyDelete, recursivelyCopy } from "../fsUtils.js";
 import { ensureBackendBinaryDownloaded } from "./download.js";
 import { isTryItOutDeployment } from "../deployment.js";
+import { createProject } from "../api.js";
+import { removeTryItOutPrefix } from "../deployment.js";
+import { nodeFs } from "../../../bundler/fs.js";
 
 export async function handleTryItOutDeployment(
   ctx: Context,
@@ -374,3 +388,129 @@ async function getUniqueName(
     printedMessage: `Could not generate a unique name for your deployment, please choose a different name`,
   });
 }
+/**
+ * This takes a "try it out" deployment and makes it a "local" deployment
+ * that is associated with a project in the given team.
+ */
+export async function handleLinkToProject(
+  ctx: Context,
+  args: {
+    deploymentName: string;
+    teamSlug: string;
+    projectSlug: string | null;
+  },
+): Promise<{
+  deploymentName: string;
+  deploymentUrl: string;
+  projectSlug: string;
+}> {
+  logVerbose(
+    ctx,
+    `Linking ${args.deploymentName} to a project in team ${args.teamSlug}`,
+  );
+  const config = await loadDeploymentConfig(
+    ctx,
+    "tryItOut",
+    args.deploymentName,
+  );
+  if (config === null) {
+    return ctx.crash({
+      exitCode: 1,
+      errorType: "fatal",
+      printedMessage: "Failed to load deployment config",
+    });
+  }
+  await ensureBackendStopped(ctx, {
+    ports: {
+      cloud: config.ports.cloud,
+    },
+    deploymentName: args.deploymentName,
+    allowOtherDeployments: true,
+    maxTimeSecs: 5,
+  });
+  const projectName = removeTryItOutPrefix(args.deploymentName);
+  let projectSlug: string;
+  if (args.projectSlug !== null) {
+    projectSlug = args.projectSlug;
+  } else {
+    const { projectSlug: newProjectSlug } = await createProject(ctx, {
+      teamSlug: args.teamSlug,
+      projectName,
+      deploymentTypeToProvision: "prod",
+    });
+    projectSlug = newProjectSlug;
+  }
+  logVerbose(ctx, `Creating local deployment in project ${projectSlug}`);
+  // Register it in big brain
+  const { deploymentName: localDeploymentName, adminKey } = await bigBrainStart(
+    ctx,
+    {
+      port: config.ports.cloud,
+      projectSlug,
+      teamSlug: args.teamSlug,
+      instanceName: null,
+    },
+  );
+  const localConfig = loadDeploymentConfig(ctx, "local", localDeploymentName);
+  if (localConfig !== null) {
+    return ctx.crash({
+      exitCode: 1,
+      errorType: "fatal",
+      printedMessage: `Project ${projectSlug} already has a local deployment, so we cannot link this try-it-out deployment to it.`,
+    });
+  }
+  logVerbose(ctx, `Moving ${args.deploymentName} to ${localDeploymentName}`);
+  await moveDeployment(
+    ctx,
+    {
+      deploymentKind: "tryItOut",
+      deploymentName: args.deploymentName,
+    },
+    {
+      deploymentKind: "local",
+      deploymentName: localDeploymentName,
+    },
+  );
+  logVerbose(ctx, `Saving deployment config for ${localDeploymentName}`);
+  await saveDeploymentConfig(ctx, "local", localDeploymentName, {
+    adminKey,
+    backendVersion: config.backendVersion,
+    ports: config.ports,
+  });
+  await bigBrainPause(ctx, {
+    projectSlug,
+    teamSlug: args.teamSlug,
+  });
+  logFinishedStep(
+    ctx,
+    `Linked ${args.deploymentName} to project ${projectSlug}`,
+  );
+  return {
+    projectSlug,
+    deploymentName: localDeploymentName,
+    deploymentUrl: localDeploymentUrl(config.ports.cloud),
+  };
+}
+
+export async function moveDeployment(
+  ctx: Context,
+  oldDeployment: {
+    deploymentKind: LocalDeploymentKind;
+    deploymentName: string;
+  },
+  newDeployment: {
+    deploymentKind: LocalDeploymentKind;
+    deploymentName: string;
+  },
+) {
+  const oldPath = deploymentStateDir(
+    oldDeployment.deploymentKind,
+    oldDeployment.deploymentName,
+  );
+  const newPath = deploymentStateDir(
+    newDeployment.deploymentKind,
+    newDeployment.deploymentName,
+  );
+  await recursivelyCopy(ctx, nodeFs, oldPath, newPath);
+  recursivelyDelete(ctx, oldPath);
+}