Deploy option to enable continuous deployment

docs/deploying.md

@@ -36,9 +36,11 @@ npm run deploy -- --help
 
 </div>
 
-## Automated deploys
+## Continuous deployment
 
-After deploying an app manually at least once, Observable can handle subsequent deploys for you automatically. You can automate deploys both [on commit](https://observablehq.com/documentation/data-apps/github) (whenever you push a new commit to your project’s default branch) and [on schedule](https://observablehq.com/documentation/data-apps/schedules) (such as daily or weekly).
+<!-- TODO: decide whether to primarily use “continuous deployment” or “automatic deploys” -->
+
+You can connect your app to Observable to handle deploys automatically. You can automate deploys both [on commit](https://observablehq.com/documentation/data-apps/github) (whenever you push a new commit to your project’s default branch) and [on schedule](https://observablehq.com/documentation/data-apps/schedules) (such as daily or weekly).
 
 Automatic deploys — also called _continuous deployment_ or _CD_ — ensure that your data is always up to date, and that any changes you make to your app are immediately reflected in the deployed version.
 
@@ -88,7 +90,7 @@ To create an API key:
 
 1. Open the [API Key settings](https://observablehq.com/select-workspace?next=api-keys-settings) for your Observable workspace.
 2. Click **New API Key**.
-3. Check the **Deploy new versions of projects** checkbox. <!-- TODO apps -->
+3. Check the **Deploy new versions of data apps** checkbox.
 4. Give your key a description, such as “Deploy via GitHub Actions”.
 5. Click **Create API Key**.
 
@@ -147,7 +149,8 @@ The contents of the deploy config file look like this:
 {
   "projectId": "0123456789abcdef",
   "projectSlug": "hello-framework",
-  "workspaceLogin": "acme"
+  "workspaceLogin": "acme",
+  "continuousDeployment": true
 }
 ```
 

src/deploy.ts

@@ -1,7 +1,10 @@
+import {exec} from "node:child_process";
 import {createHash} from "node:crypto";
 import type {Stats} from "node:fs";
+import {existsSync} from "node:fs";
 import {readFile, stat} from "node:fs/promises";
 import {join} from "node:path/posix";
+import {promisify} from "node:util";
 import slugify from "@sindresorhus/slugify";
 import wrapAnsi from "wrap-ansi";
 import type {BuildEffects, BuildManifest, BuildOptions} from "./build.js";
@@ -15,7 +18,7 @@ import {visitFiles} from "./files.js";
 import type {Logger} from "./logger.js";
 import type {AuthEffects} from "./observableApiAuth.js";
 import {defaultEffects as defaultAuthEffects, formatUser, loginInner, validWorkspaces} from "./observableApiAuth.js";
-import {ObservableApiClient} from "./observableApiClient.js";
+import {ObservableApiClient, getObservableUiOrigin} from "./observableApiClient.js";
 import type {
   DeployManifestFile,
   GetCurrentUserResponse,
@@ -33,6 +36,46 @@ const DEPLOY_POLL_MAX_MS = 1000 * 60 * 5;
 const DEPLOY_POLL_INTERVAL_MS = 1000 * 5;
 const BUILD_AGE_WARNING_MS = 1000 * 60 * 5;
 
+const OBSERVABLE_UI_ORIGIN = getObservableUiOrigin();
+
+function settingsUrl(deployTarget: DeployTargetInfo) {
+  if (deployTarget.create) {
+    throw new Error("Incorrect deploy target state");
+  }
+  return `${OBSERVABLE_UI_ORIGIN}projects/@${deployTarget.workspace.login}/${deployTarget.project.slug}`;
+}
+
+/**
+ * Returns the ownerName and repoName of the first GitHub remote (HTTPS or SSH)
+ * on the current repository, or null.
+ */
+async function getGitHubRemote() {
+  const remotes = (await promisify(exec)("git remote -v")).stdout
+    .split("\n")
+    .filter((d) => d)
+    .map((d) => {
+      const [, url] = d.split(/\s/g);
+      if (url.startsWith("https://github.com/")) {
+        // HTTPS: https://github.com/observablehq/framework.git
+        const [ownerName, repoName] = new URL(url).pathname
+          .slice(1)
+          .replace(/\.git$/, "")
+          .split("/");
+        return {ownerName, repoName};
+      } else if (url.startsWith("[email protected]:")) {
+        // SSH: [email protected]:observablehq/framework.git
+        const [ownerName, repoName] = url
+          .replace(/^[email protected]:/, "")
+          .replace(/\.git$/, "")
+          .split("/");
+        return {ownerName, repoName};
+      }
+    });
+  const remote = remotes.find((d) => d && d.ownerName && d.repoName);
+  if (!remote) throw new CliError("No GitHub remote found.");
+  return remote ?? null;
+}
+
 export interface DeployOptions {
   config: Config;
   deployConfigPath: string | undefined;
@@ -84,7 +127,7 @@ type DeployTargetInfo =
   | {create: true; workspace: {id: string; login: string}; projectSlug: string; title: string; accessLevel: string}
   | {create: false; workspace: {id: string; login: string}; project: GetProjectResponse};
 
-/** Deploy a project to ObservableHQ */
+/** Deploy a project to Observable */
 export async function deploy(deployOptions: DeployOptions, effects = defaultEffects): Promise<void> {
   Telemetry.record({event: "deploy", step: "start", force: deployOptions.force});
   effects.clack.intro(`${inverse(" observable deploy ")} ${faint(`v${process.env.npm_package_version}`)}`);
@@ -190,14 +233,149 @@ class Deployer {
     return deployInfo;
   }
 
-  private async startNewDeploy(): Promise<GetDeployResponse> {
-    const deployConfig = await this.getUpdatedDeployConfig();
-    const deployTarget = await this.getDeployTarget(deployConfig);
-    const buildFilePaths = await this.getBuildFilePaths();
-    const deployId = await this.createNewDeploy(deployTarget);
+  private async cloudBuild(deployTarget: DeployTargetInfo) {
+    if (deployTarget.create) {
+      throw new Error("Incorrect deploy target state");
+    }
+    const {deployPollInterval: pollInterval = DEPLOY_POLL_INTERVAL_MS} = this.deployOptions;
+    await this.apiClient.postProjectBuild(deployTarget.project.id);
+    const spinner = this.effects.clack.spinner();
+    spinner.start("Requesting deploy");
+    const pollExpiration = Date.now() + DEPLOY_POLL_MAX_MS;
+    while (true) {
+      if (Date.now() > pollExpiration) {
+        spinner.stop("Requesting deploy timed out.");
+        throw new CliError("Requesting deploy failed");
+      }
+      const {latestCreatedDeployId} = await this.apiClient.getProject({
+        workspaceLogin: deployTarget.workspace.login,
+        projectSlug: deployTarget.project.slug
+      });
+      if (latestCreatedDeployId !== deployTarget.project.latestCreatedDeployId) {
+        spinner.stop(
+          `Deploy started. Watch logs: ${link(`${settingsUrl(deployTarget)}/deploys/${latestCreatedDeployId}`)}`
+        );
+        // latestCreatedDeployId is initially null for a new project, but once
+        // it changes to a string it can never change back; since we know it has
+        // changed, we assert here that it’s not null
+        return latestCreatedDeployId!;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
 
-    await this.uploadFiles(deployId, buildFilePaths);
-    await this.markDeployUploaded(deployId);
+  // Throws error if local and remote GitHub repos don’t match or are invalid
+  private async validateGitHubLink(deployTarget: DeployTargetInfo): Promise<void> {
+    if (deployTarget.create) {
+      throw new Error("Incorrect deploy target state");
+    }
+    if (!deployTarget.project.build_environment_id) {
+      // TODO: allow setting build environment from CLI
+      throw new CliError("No build environment configured.");
+    }
+    // We only support cloud builds from the root directory so this ignores
+    // this.deployOptions.config.root
+    const isGit = existsSync(".git");
+    if (!isGit) throw new CliError("Not at root of a git repository.");
+
+    const {ownerName, repoName} = await getGitHubRemote();
+    const branch = (await promisify(exec)("git rev-parse --abbrev-ref HEAD")).stdout.trim();
+    let localRepo = await this.apiClient.getGitHubRepository({ownerName, repoName});
+
+    // If a source repository has already been configured, check that it’s
+    // accessible and matches the local repository and branch.
+    // TODO: validate local/remote refs match, "Your branch is up to date",
+    // and "nothing to commit, working tree clean".
+    const {source} = deployTarget.project;
+    if (source) {
+      if (localRepo && source.provider_id !== localRepo.provider_id) {
+        throw new CliError(
+          `Configured repository does not match local repository; check build settings on ${link(
+            `${settingsUrl(deployTarget)}/settings`
+          )}`
+        );
+      }
+      if (localRepo && source.branch && source.branch !== branch) {
+        // TODO: If source.branch is empty, it'll use the default repository
+        // branch (usually main or master), which we don't know from our current
+        // getGitHubRepository response, and thus can't check here.
+        throw new CliError(
+          `Configured branch does not match local branch; check build settings on ${link(
+            `${settingsUrl(deployTarget)}/settings`
+          )}`
+        );
+      }
+      const remoteAuthedRepo = await this.apiClient.getGitHubRepository({
+        providerId: source.provider_id
+      });
+      if (!remoteAuthedRepo) {
+        // TODO: This could poll for auth too, but is a distinct case because it
+        // means the repo was linked at one point and then something went wrong
+        throw new CliError(
+          `Cannot access configured repository; check build settings on ${link(
+            `${settingsUrl(deployTarget)}/settings`
+          )}`
+        );
+      }
+
+      // Configured repo is OK; proceed
+      return;
+    }
+
+    if (!localRepo) {
+      if (!this.effects.isTty)
+        throw new CliError(
+          "Cannot access repository for continuous deployment and cannot request access in non-interactive mode"
+        );
+
+      // Repo is not authorized; link to auth page and poll for auth
+      const authUrl = new URL("/auth-github", OBSERVABLE_UI_ORIGIN);
+      authUrl.searchParams.set("owner", ownerName);
+      authUrl.searchParams.set("repo", repoName);
+      this.effects.clack.log.info(`Authorize Observable to access the ${bold(repoName)} repository: ${link(authUrl)}`);
+
+      const spinner = this.effects.clack.spinner();
+      spinner.start("Waiting for repository to be authorized");
+      const {deployPollInterval: pollInterval = DEPLOY_POLL_INTERVAL_MS} = this.deployOptions;
+      const pollExpiration = Date.now() + DEPLOY_POLL_MAX_MS;
+      while (!localRepo) {
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        if (Date.now() > pollExpiration) {
+          spinner.stop("Waiting for repository to be authorized timed out.");
+          throw new CliError("Repository authorization failed");
+        }
+        localRepo = await this.apiClient.getGitHubRepository({ownerName, repoName});
+        if (localRepo) spinner.stop("Repository authorized.");
+      }
+    }
+
+    const response = await this.apiClient.postProjectEnvironment(deployTarget.project.id, {
+      source: {
+        provider: localRepo.provider,
+        provider_id: localRepo.provider_id,
+        url: localRepo.url,
+        branch
+      }
+    });
+
+    if (!response) throw new CliError("Setting source repository for continuous deployment failed");
+
+    // Configured repo is OK; proceed
+    return;
+  }
+
+  private async startNewDeploy(): Promise<GetDeployResponse> {
+    const {deployConfig, deployTarget} = await this.getDeployTarget(await this.getUpdatedDeployConfig());
+    let deployId: string | null;
+    if (deployConfig.continuousDeployment) {
+      await this.validateGitHubLink(deployTarget);
+      deployId = await this.cloudBuild(deployTarget);
+    } else {
+      const buildFilePaths = await this.getBuildFilePaths();
+      deployId = await this.createNewDeploy(deployTarget);
+      await this.uploadFiles(deployId, buildFilePaths);
+      await this.markDeployUploaded(deployId);
+    }
     return await this.pollForProcessingCompletion(deployId);
   }
 
@@ -274,7 +452,9 @@ class Deployer {
   }
 
   // Get the deploy target, prompting the user as needed.
-  private async getDeployTarget(deployConfig: DeployConfig): Promise<DeployTargetInfo> {
+  private async getDeployTarget(
+    deployConfig: DeployConfig
+  ): Promise<{deployTarget: DeployTargetInfo; deployConfig: DeployConfig}> {
     let deployTarget: DeployTargetInfo;
     if (deployConfig.workspaceLogin && deployConfig.projectSlug) {
       try {
@@ -384,18 +564,37 @@ class Deployer {
       }
     }
 
+    let {continuousDeployment} = deployConfig;
+    if (continuousDeployment === null) {
+      const enable = await this.effects.clack.confirm({
+        message: wrapAnsi(
+          `Do you want to enable continuous deployment? ${faint(
+            "Given a GitHub repository, this builds in the cloud and redeploys whenever you push to the current branch."
+          )}`,
+          this.effects.outputColumns
+        ),
+        active: "Yes, enable and build in cloud",
+        inactive: "No, build locally"
+      });
+      if (this.effects.clack.isCancel(enable)) throw new CliError("User canceled deploy", {print: false, exitCode: 0});
+      continuousDeployment = enable;
+    }
+
+    const newDeployConfig = {
+      projectId: deployTarget.project.id,
+      projectSlug: deployTarget.project.slug,
+      workspaceLogin: deployTarget.workspace.login,
+      continuousDeployment
+    };
+
     await this.effects.setDeployConfig(
       this.deployOptions.config.root,
       this.deployOptions.deployConfigPath,
-      {
-        projectId: deployTarget.project.id,
-        projectSlug: deployTarget.project.slug,
-        workspaceLogin: deployTarget.workspace.login
-      },
+      newDeployConfig,
       this.effects
     );
 
-    return deployTarget;
+    return {deployConfig: newDeployConfig, deployTarget};
   }
 
   // Create the new deploy on the server.