Check for gh-pages branch on Remote but also locally.

publishing workflow needs to ensure that gh-pages does not exists yet before creating it, or offer to publish it on remote if existing.

This allows to handle more potential error while publishing like #9585

Author: cderv

src/core/git.ts

@@ -64,3 +64,21 @@ export async function lsFiles(
 
   return Promise.resolve(undefined);
 }
+
+export async function gitBranchExists(
+  branch: string,
+  cwd?: string,
+): Promise<boolean | undefined> {
+  if (await which("git")) {
+    const result = await execProcess({
+      cmd: ["git", "show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
+      cwd,
+      stdout: "piped",
+      stderr: "piped",
+    });
+
+    return result.code === 0;
+  }
+
+  return Promise.resolve(undefined);
+}

src/core/github-types.ts

@@ -9,7 +9,8 @@ export type GitHubContext = {
   repo: boolean;
   originUrl?: string;
   repoUrl?: string;
-  ghPages?: boolean;
+  ghPagesRemote?: boolean;
+  ghPagesLocal?: boolean;
   siteUrl?: string;
   browse?: boolean;
   organization?: string;

src/core/github.ts

@@ -11,6 +11,7 @@ import { join } from "../deno_ral/path.ts";
 import { existsSync } from "fs/mod.ts";
 import { isHttpUrl } from "./url.ts";
 import { GitHubContext } from "./github-types.ts";
+import { gitBranchExists } from "./git.ts";
 
 export async function gitHubContext(dir: string) {
   // establish dir
@@ -43,7 +44,7 @@ export async function gitHubContext(dir: string) {
         context.originUrl = result.stdout?.trim();
 
         // check for a gh-pages branch
-        context.ghPages = (await execProcess({
+        const ghPagesRemote = await execProcess({
           cmd: [
             "git",
             "ls-remote",
@@ -54,7 +55,22 @@ export async function gitHubContext(dir: string) {
           ],
           stdout: "piped",
           stderr: "piped",
-        })).success;
+        });
+
+        context.ghPagesRemote = ghPagesRemote.success;
+        if (!ghPagesRemote.success) {
+          // when no gh-pages branch on remote, check local to avoid creation error
+          // as if local branch exists, we don't want to create a new one
+          // https://git-scm.com/docs/git-ls-remote#Documentation/git-ls-remote.txt---exit-code
+          if (ghPagesRemote.code === 2) {
+            context.ghPagesLocal = await gitBranchExists("gh-pages");
+          } else {
+            // if we go there, this means something is not right with the remote origin
+            throw new Error(
+              `There is an error while retrieving information from remote 'origin'.\n Git error: ${ghPagesRemote.stderr}. \n Git status code: ${ghPagesRemote.code}.`,
+            );
+          }
+        }
 
         // determine siteUrl
         context.siteUrl = siteUrl(

src/publish/gh-pages/gh-pages.ts

@@ -27,7 +27,7 @@ import { joinUrl } from "../../core/url.ts";
 import { completeMessage, withSpinner } from "../../core/console.ts";
 import { renderForPublish } from "../common/publish.ts";
 import { RenderFlags } from "../../command/render/types.ts";
-import { gitCmds, gitVersion } from "../../core/git.ts";
+import { gitBranchExists, gitCmds, gitVersion } from "../../core/git.ts";
 import {
   anonymousAccount,
   gitHubContextForPublish,
@@ -71,7 +71,7 @@ async function publishRecord(
   input: string | ProjectContext,
 ): Promise<PublishRecord | undefined> {
   const ghContext = await gitHubContextForPublish(input);
-  if (ghContext.ghPages) {
+  if (ghContext.ghPagesRemote) {
     return {
       id: "gh-pages",
       url: ghContext.siteUrl || ghContext.originUrl,
@@ -114,17 +114,27 @@ async function publish(
   const ghContext = await gitHubContextForPublish(options.input);
   verifyContext(ghContext, "GitHub Pages");
 
-  // create gh pages branch if there is none yet
-  const createGhPagesBranch = !ghContext.ghPages;
-  if (createGhPagesBranch) {
+  // create gh pages branch on remote and local if there is none yet
+  const createGhPagesBranchRemote = !ghContext.ghPagesRemote;
+  const createGhPagesBranchLocal = !ghContext.ghPagesLocal;
+  if (createGhPagesBranchRemote) {
     // confirm
-    const confirmed = await Confirm.prompt({
+    let confirmed = await Confirm.prompt({
       indent: "",
       message: `Publish site to ${
         ghContext.siteUrl || ghContext.originUrl
       } using gh-pages?`,
       default: true,
     });
+    if (confirmed && !createGhPagesBranchLocal) {
+      confirmed = await Confirm.prompt({
+        indent: "",
+        message:
+          `A local gh-pages branch already exists. Should it be pushed to remote 'origin'?`,
+        default: true,
+      });
+    }
+
     if (!confirmed) {
       throw new Error();
     }
@@ -135,9 +145,29 @@ async function publish(
     }
     const oldBranch = await gitCurrentBranch(input);
     try {
-      await gitCreateGhPages(input);
+      // Create and push if necessary, or just push local branch
+      if (createGhPagesBranchLocal) {
+        await gitCreateGhPages(input);
+      } else {
+        await gitPushGhPages(input);
+      }
+    } catch {
+      // Something failed so clean up, i.e
+      // if we created the branch then delete it.
+      // Example of failure: Auth error on push (https://github.com/quarto-dev/quarto-cli/issues/9585)
+      if (createGhPagesBranchLocal && await gitBranchExists("gh-pages")) {
+        await gitCmds(input, [
+          ["checkout", oldBranch],
+          ["branch", "-D", "gh-pages"],
+        ]);
+      }
+      throw new Error(
+        "Publishing to gh-pages with `quarto publish gh-pages` failed.",
+      );
     } finally {
-      await gitCmds(input, [["checkout", oldBranch]]);
+      if (await gitCurrentBranch(input) !== oldBranch) {
+        await gitCmds(input, [["checkout", oldBranch]]);
+      }
       if (stash) {
         await gitStashApply(input);
       }
@@ -360,7 +390,14 @@ async function gitCreateGhPages(dir: string) {
   await gitCmds(dir, [
     ["checkout", "--orphan", "gh-pages"],
     ["rm", "-rf", "--quiet", "."],
-    ["commit", "--allow-empty", "-m", `Initializing gh-pages branch`],
-    ["push", "origin", `HEAD:gh-pages`],
+    ["commit", "--allow-empty", "-m", "Initializing gh-pages branch"],
   ]);
+  await gitPushGhPages(dir);
+}
+
+async function gitPushGhPages(dir: string) {
+  if (await gitCurrentBranch(dir) !== "gh-pages") {
+    await gitCmds(dir, [["checkout", "gh-pages"]]);
+  }
+  await gitCmds(dir, [["push", "origin", "HEAD:gh-pages"]]);
 }

src/publish/huggingface/huggingface.ts

@@ -70,7 +70,7 @@ async function publishRecord(
   input: string | ProjectContext,
 ): Promise<PublishRecord | undefined> {
   const ghContext = await gitHubContextForPublish(input);
-  if (ghContext.ghPages) {
+  if (ghContext.ghPagesRemote) {
     return {
       id: kHuggingFace,
       url: ghContext.siteUrl || ghContext.originUrl,