@plutocms/core 0.47.0 → 0.48.0

package/modules/pluto-github/runtime/server/store/local-git.ts

@@ -74,3 +74,148 @@ export async function commitLocalFiles(
   await git(root, ['commit', '-m', message, '--', ...staged])
   return { committed: true, sha: await git(root, ['rev-parse', 'HEAD']) }
 }
+
+/** The state of the local Git repo, for the backend badge of the admin (local mode). */
+export type LocalGitStatus =
+  | { repo: false; reason: 'not-a-repo' | 'no-git' }
+  | {
+      repo: true
+      /** The current branch. `null` on a detached HEAD. */
+      branch: string | null
+      /** The upstream of the branch, for example `origin/main`. `null` when it has none. */
+      upstream: string | null
+      /** The remote that a push uses: the remote of the upstream, else `origin`, else the first. */
+      remote: string | null
+      /** The commits that are not pushed: not on the upstream, or on no remote at all. */
+      ahead: number
+    }
+
+/** Why a push failed. `rejected`: the remote has commits that this repo has not (pull first). */
+export type LocalPushError =
+  | 'not-a-repo'
+  | 'detached'
+  | 'no-remote'
+  | 'rejected'
+  | 'auth'
+  | 'timeout'
+  | 'failed'
+
+export class LocalPushFailure extends Error {
+  constructor(readonly reason: LocalPushError) {
+    super(`git push failed: ${reason}`)
+  }
+}
+
+async function gitOrNull(root: string, args: string[]): Promise<string | null> {
+  try {
+    return await git(root, args)
+  } catch {
+    return null
+  }
+}
+
+/** Reads the branch, the upstream and the commits that are not pushed. It runs no network call. */
+export async function readLocalGitStatus(
+  root: string
+): Promise<LocalGitStatus> {
+  try {
+    if ((await git(root, ['rev-parse', '--is-inside-work-tree'])) !== 'true') {
+      return { repo: false, reason: 'not-a-repo' }
+    }
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code
+    return { repo: false, reason: code === 'ENOENT' ? 'no-git' : 'not-a-repo' }
+  }
+
+  const branch =
+    (await gitOrNull(root, ['symbolic-ref', '--short', '-q', 'HEAD'])) || null
+  const upstream =
+    (await gitOrNull(root, [
+      'rev-parse',
+      '--abbrev-ref',
+      '--symbolic-full-name',
+      '@{u}',
+    ])) || null
+  const remotes = ((await gitOrNull(root, ['remote'])) ?? '')
+    .split('\n')
+    .filter(Boolean)
+  const upstreamRemote = upstream
+    ? remotes.find((name) => upstream.startsWith(`${name}/`))
+    : undefined
+  const remote =
+    upstreamRemote ??
+    (remotes.includes('origin') ? 'origin' : (remotes[0] ?? null))
+
+  // With an upstream: the commits that it lacks. Without one: the commits on no remote branch. A
+  // repo with no commit yet has no HEAD, so the count fails and reads as 0.
+  const count = await gitOrNull(
+    root,
+    upstream
+      ? ['rev-list', '--count', '@{u}..HEAD']
+      : ['rev-list', '--count', 'HEAD', '--not', '--remotes']
+  )
+  const ahead = Math.max(0, Number.parseInt(count ?? '0', 10) || 0)
+
+  return { repo: true, branch, upstream, remote, ahead }
+}
+
+/** Sorts the stderr text of a failed push into a reason. */
+export function pushErrorReason(stderr: string): LocalPushError {
+  if (/\[rejected\]|non-fast-forward|fetch first/i.test(stderr)) {
+    return 'rejected'
+  }
+  if (
+    /authentication failed|could not read username|permission denied|terminal prompts disabled|error: 403|returned error: 403/i.test(
+      stderr
+    )
+  ) {
+    return 'auth'
+  }
+  return 'failed'
+}
+
+/**
+ * Pushes the current branch. A branch with no upstream is pushed to the remote of the status and
+ * gets it as its upstream. Git never asks for a password in the terminal (`GIT_TERMINAL_PROMPT=0`),
+ * and the push stops after `timeout` ms. A credential helper of the system can still ask in a
+ * window. Throws `LocalPushFailure`.
+ */
+export async function pushLocalGit(
+  root: string,
+  options: { timeout?: number } = {}
+): Promise<LocalGitStatus> {
+  const status = await readLocalGitStatus(root)
+  if (!status.repo) {
+    throw new LocalPushFailure('not-a-repo')
+  }
+  if (!status.branch) {
+    throw new LocalPushFailure('detached')
+  }
+  if (!status.remote) {
+    throw new LocalPushFailure('no-remote')
+  }
+
+  const args = status.upstream
+    ? ['push']
+    : ['push', '--set-upstream', '--', status.remote, status.branch]
+  try {
+    await run('git', args, {
+      cwd: root,
+      windowsHide: true,
+      timeout: options.timeout ?? 120_000,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    })
+  } catch (error) {
+    const failure = error as NodeJS.ErrnoException & {
+      killed?: boolean
+      signal?: string | null
+      stderr?: string
+    }
+    if (failure.killed || failure.signal === 'SIGTERM') {
+      throw new LocalPushFailure('timeout')
+    }
+    throw new LocalPushFailure(pushErrorReason(String(failure.stderr ?? '')))
+  }
+
+  return readLocalGitStatus(root)
+}

package/modules/pluto-github/runtime/server/store/memory.ts

@@ -31,7 +31,10 @@ export function createMemoryStore(
 
   function currentHead(): string {
     return listingOid(
-      [...files, ...raw].map(([path, text]) => ({ path, oid: gitBlobSha(text) }))
+      [...files, ...raw].map(([path, text]) => ({
+        path,
+        oid: gitBlobSha(text),
+      }))
     )
   }
 

package/modules/pluto-github/runtime/server/utils/build-status.ts

@@ -8,7 +8,11 @@ import type {
 } from '../../shared/build-status'
 import { setResponseHeader } from 'h3'
 import { createPlutoError } from '../../../../../server/utils/pluto-error'
-import { commitHeadline, reduceBuildStatus } from '../../shared/build-status'
+import {
+  commitHeadline,
+  pickDeployCommit,
+  reduceBuildStatus,
+} from '../../shared/build-status'
 import { githubRest } from '../github/client'
 import { PlutoGithubStoreError } from '../store/errors'
 import { getGithubConfig } from './github-config'
@@ -17,6 +21,8 @@ import { requireGithubSession } from './session'
 /** Milliseconds that the sources of one commit stay in memory, for each user. */
 const SOURCES_TTL_MS = 3_000
 const MAX_ENTRIES = 200
+/** The newest commits that the route reads to find the last one that did not skip CI. */
+const COMMITS_TO_SCAN = 20
 /** The most environments that the route reads. Each one costs one GitHub call. */
 const MAX_DEPLOYMENTS = 5
 
@@ -159,8 +165,8 @@ async function loadSources(
   return { checkRuns, statuses, deployments, unavailable }
 }
 
-/** Maps an error of the GitHub call to an HTTP error, like the content adapter does. */
-function toHttpError(error: unknown, event: H3Event): unknown {
+/** Maps an error of a GitHub call to an HTTP error, like the content adapter does. The users route uses it too. */
+export function toHttpError(error: unknown, event: H3Event): unknown {
   if (!(error instanceof PlutoGithubStoreError)) {
     return error
   }
@@ -203,8 +209,8 @@ function toHttpError(error: unknown, event: H3Event): unknown {
 }
 
 /**
- * Route: GET /api/_pluto/github/build-status. The state of the builds of the head
- * commit of the content branch: check runs, commit statuses and deployments.
+ * Route: GET /api/_pluto/github/build-status. The state of the builds of the newest commit of the
+ * content branch that did not skip CI: check runs, commit statuses and deployments.
  * It needs a signed-in user and reads with the token of that user. The `fs`
  * store has no builds, so it answers `none`.
  */
@@ -225,10 +231,13 @@ export async function handleBuildStatus(
     fetch: config.fetch,
   }
   try {
-    const { data: commit } = await githubRest<RawCommit>(
-      `/repos/${config.repo}/commits/${encodeURIComponent(config.branch)}`,
+    // A draft save skips the deploy (`[skip ci]`), so the newest commit that did not skip it has
+    // the builds of the site.
+    const { data: commits } = await githubRest<RawCommit[]>(
+      `/repos/${config.repo}/commits?sha=${encodeURIComponent(config.branch)}&per_page=${COMMITS_TO_SCAN}`,
       request
     )
+    const commit = pickDeployCommit(Array.isArray(commits) ? commits : [])
     const sha = String(commit?.sha ?? '')
     if (!/^[0-9a-f]{7,64}$/i.test(sha)) {
       throw new PlutoGithubStoreError(

package/modules/pluto-github/runtime/server/utils/deploy.ts

@@ -0,0 +1,204 @@
+import type { H3Event } from 'h3'
+import type {
+  PlutoDeployStatus,
+  PlutoPagesSetupResult,
+  PlutoPagesState,
+} from '../../shared/deploy'
+import { execFile } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { promisify } from 'node:util'
+import { createError, setResponseHeader } from 'h3'
+import {
+  defaultPagesUrl,
+  detectPackageManager,
+  PAGES_WORKFLOW_PATH,
+  renderPagesWorkflow,
+} from '../../shared/pages-workflow'
+import { commitLocalFiles } from '../store/local-git'
+import { getGithubConfig } from './github-config'
+import { isLocalRequest, requireGithubSession } from './session'
+
+const run = promisify(execFile)
+
+/** A repo name that is safe to put in a `gh api` path. */
+const REPO_NAME = /^[\w.-]+\/[\w.-]+$/
+
+async function gh(args: string[]): Promise<string> {
+  const { stdout } = await run('gh', args, {
+    windowsHide: true,
+    timeout: 30_000,
+    env: { ...process.env, GH_PROMPT_DISABLED: '1' },
+  })
+  return stdout
+}
+
+/** Sorts a failure of `gh` into a reason, and `off` for a 404. */
+function ghFailure(error: unknown): PlutoPagesState {
+  const failure = error as NodeJS.ErrnoException & { stderr?: string }
+  if (failure.code === 'ENOENT') {
+    return { state: 'unknown', reason: 'no-gh' }
+  }
+  const text = String(failure.stderr ?? failure.message ?? '')
+  if (/HTTP 404|Not Found/i.test(text)) {
+    return { state: 'off' }
+  }
+  if (/gh auth login|not logged in|authentication/i.test(text)) {
+    return { state: 'unknown', reason: 'signed-out' }
+  }
+  return { state: 'unknown', reason: 'error' }
+}
+
+/** Reads the Pages site of the repo with `gh api`. It never throws. */
+export async function readPagesState(repo: string): Promise<PlutoPagesState> {
+  if (!REPO_NAME.test(repo)) {
+    return { state: 'unknown', reason: 'error' }
+  }
+  try {
+    const site = JSON.parse(await gh(['api', `repos/${repo}/pages`])) as {
+      html_url?: string
+      build_type?: string
+    }
+    return {
+      state: 'on',
+      url: site.html_url,
+      source: site.build_type === 'workflow' ? 'workflow' : 'legacy',
+    }
+  } catch (error) {
+    return ghFailure(error)
+  }
+}
+
+/**
+ * Turns Pages on for the repo with the Actions source (`build_type=workflow`), or moves a site
+ * that builds from a branch to the Actions source. Needs `gh` signed in as a user who administers
+ * the repo. Returns the new state.
+ */
+export async function enablePages(repo: string): Promise<PlutoPagesState> {
+  const current = await readPagesState(repo)
+  if (current.state === 'on' && current.source === 'workflow') {
+    return current
+  }
+  if (current.state === 'unknown') {
+    return current
+  }
+  try {
+    await gh([
+      'api',
+      '-X',
+      current.state === 'on' ? 'PUT' : 'POST',
+      `repos/${repo}/pages`,
+      '-f',
+      'build_type=workflow',
+    ])
+  } catch (error) {
+    return ghFailure(error)
+  }
+  return readPagesState(repo)
+}
+
+/** The local mode of this request: a dev build, the `fs` store, and this computer. */
+function isLocalMode(event: H3Event): boolean {
+  const config = getGithubConfig()
+  return (
+    config.dev &&
+    config.storage === 'fs' &&
+    Boolean(config.fsRoot) &&
+    isLocalRequest(event)
+  )
+}
+
+async function rootFiles(root: string): Promise<string[]> {
+  try {
+    return await readdir(root)
+  } catch {
+    return []
+  }
+}
+
+async function buildStatus(local: boolean): Promise<PlutoDeployStatus> {
+  const config = getGithubConfig()
+  const root = config.fsRoot
+  const packageManager = detectPackageManager(
+    local ? await rootFiles(root) : []
+  )
+  const text = renderPagesWorkflow({ branch: config.branch, packageManager })
+  const status: PlutoDeployStatus = {
+    repo: config.repo,
+    branch: config.branch,
+    local,
+    packageManager,
+    workflow: { path: PAGES_WORKFLOW_PATH, text },
+    pagesUrl: config.repo ? defaultPagesUrl(config.repo) : '',
+  }
+  if (local) {
+    const file = join(root, PAGES_WORKFLOW_PATH)
+    const exists = existsSync(file)
+    status.workflow.exists = exists
+    status.workflow.current = exists && (await readFile(file, 'utf8')) === text
+    status.pages = config.repo
+      ? await readPagesState(config.repo)
+      : { state: 'unknown', reason: 'error' }
+  }
+  return status
+}
+
+/**
+ * Route: GET /api/_pluto/github/deploy/status. The facts that the Deploy page needs: the repo,
+ * the branch, and the GitHub Pages workflow to copy. In local mode on this computer it also says
+ * whether the workflow is in the project and whether Pages is on (with `gh`). It needs a signed-in
+ * user.
+ */
+export async function handleDeployStatus(
+  event: H3Event
+): Promise<PlutoDeployStatus> {
+  setResponseHeader(event, 'Cache-Control', 'no-store')
+  await requireGithubSession(event)
+  return buildStatus(isLocalMode(event))
+}
+
+/**
+ * Route: POST /api/_pluto/github/deploy/pages. Local mode on this computer only (404 otherwise).
+ * It writes the workflow when it is missing or old, commits it to the local repo, and turns Pages
+ * on with `gh` (the Actions source). The author pushes to deploy.
+ */
+export async function handleSetupPages(
+  event: H3Event
+): Promise<PlutoPagesSetupResult> {
+  setResponseHeader(event, 'Cache-Control', 'no-store')
+  if (!isLocalMode(event)) {
+    throw createError({ statusCode: 404 })
+  }
+  const config = getGithubConfig()
+  const before = await buildStatus(true)
+
+  let committed = false
+  if (!before.workflow.current) {
+    const file = join(config.fsRoot, PAGES_WORKFLOW_PATH)
+    await mkdir(dirname(file), { recursive: true })
+    await writeFile(file, before.workflow.text, 'utf8')
+    try {
+      const result = await commitLocalFiles(
+        config.fsRoot,
+        [PAGES_WORKFLOW_PATH],
+        'ci: deploy the site to GitHub Pages'
+      )
+      committed = result.committed
+    } catch (error) {
+      // The file is written. A hook or a missing author stops the commit only.
+      console.warn('[pluto-github] Could not commit the Pages workflow.', error)
+    }
+  }
+
+  const pages = config.repo
+    ? await enablePages(config.repo)
+    : ({ state: 'unknown', reason: 'error' } as PlutoPagesState)
+  const status = await buildStatus(true)
+  status.pages = pages
+  return {
+    status,
+    committed,
+    pagesOn: pages.state === 'on' && pages.source === 'workflow',
+  }
+}

package/modules/pluto-github/runtime/server/utils/github-setup.ts

@@ -9,9 +9,7 @@ import {
   registerContentAdapter,
   registerContentType,
 } from '../../../../../server/utils/pluto-content'
-import {
-  registerMediaDriver,
-} from '../../../../../server/utils/pluto-media-driver'
+import { registerMediaDriver } from '../../../../../server/utils/pluto-media-driver'
 import {
   isPublicRead,
   markPublicRead,

package/modules/pluto-github/runtime/server/utils/github-users.ts

@@ -0,0 +1,120 @@
+import type { H3Event } from 'h3'
+import type {
+  GithubCollaborator,
+  PlutoGithubUsersResponse,
+} from '../../shared/repo-users'
+import type { AppTokenProvider } from '../github/app-token'
+import type { GithubConfig } from './github-config'
+import { setResponseHeader } from 'h3'
+import { toRepoUsers } from '../../shared/repo-users'
+import { createAppTokenProvider } from '../github/app-token'
+import { githubRest } from '../github/client'
+import { toHttpError } from './build-status'
+import { getGithubConfig } from './github-config'
+import { requireGithubSession } from './session'
+
+/** GitHub gives at most 100 collaborators per page. The route reads at most this many pages. */
+const MAX_PAGES = 10
+/** How long one list stays in memory. Several tabs and reloads share it. */
+const CACHE_TTL = 30_000
+
+const cache = new Map<string, { at: number; value: PlutoGithubUsersResponse }>()
+let appTokens: { key: string; provider: AppTokenProvider } | undefined
+
+/** Forgets the cached lists. For tests. */
+export function clearGithubUsersCache(): void {
+  cache.clear()
+  appTokens = undefined
+}
+
+/** The token of the App (or the read token), for local mode. One provider per config. */
+function appToken(config: GithubConfig): Promise<string> {
+  const key = [config.repo, config.appId, config.apiUrl, config.readToken].join(
+    '\n'
+  )
+  if (appTokens?.key !== key) {
+    appTokens = {
+      key,
+      provider: createAppTokenProvider({
+        repo: config.repo,
+        apiUrl: config.apiUrl,
+        appId: config.appId,
+        privateKey: config.privateKey,
+        readToken: config.readToken,
+        fetch: config.fetch,
+      }),
+    }
+  }
+  return appTokens.provider.getReadToken()
+}
+
+/** Reads every collaborator with push access or more, page by page. */
+async function listCollaborators(
+  config: GithubConfig,
+  token: string
+): Promise<GithubCollaborator[]> {
+  const all: GithubCollaborator[] = []
+  for (let page = 1; page <= MAX_PAGES; page++) {
+    const { data } = await githubRest<GithubCollaborator[]>(
+      `/repos/${config.repo}/collaborators?affiliation=all&permission=push&per_page=100&page=${page}`,
+      { apiUrl: config.apiUrl, fetch: config.fetch, token }
+    )
+    all.push(...(data ?? []))
+    if (!data || data.length < 100) {
+      break
+    }
+  }
+  return all
+}
+
+/**
+ * Route: GET /api/_pluto/github/users. The people with write access to the content repo, read
+ * only. It needs a signed-in user, and reads with the token of that user. In local mode (the dev
+ * user has no GitHub token) it reads with the App installation token or the read token; with
+ * neither, it answers `reason: 'no-app'`, and `app-error` when the App gives no token (not
+ * installed on the repo, or a wrong key). Admins, then maintainers, then writers.
+ */
+export async function handleGithubUsers(
+  event: H3Event
+): Promise<PlutoGithubUsersResponse> {
+  setResponseHeader(event, 'Cache-Control', 'no-store')
+  const session = await requireGithubSession(event)
+  const config = getGithubConfig()
+  const restricted = config.allowedUsers.length > 0
+  const base = { repo: config.repo, users: [], restricted }
+
+  if (!config.repo) {
+    return { ...base, reason: 'no-repo' }
+  }
+  const local = config.storage === 'fs' || session.local === true
+  if (local && !config.readToken && !(config.appId && config.privateKey)) {
+    return { ...base, reason: 'no-app' }
+  }
+
+  const cached = cache.get(config.repo)
+  if (cached && Date.now() - cached.at < CACHE_TTL) {
+    return cached.value
+  }
+
+  let token = session.token
+  if (local) {
+    try {
+      token = await appToken(config)
+    } catch {
+      // The App is not installed on the repo, or its key is wrong. The provider logs the cause.
+      return { ...base, reason: 'app-error' }
+    }
+  }
+
+  try {
+    const users = toRepoUsers(
+      await listCollaborators(config, token),
+      config.allowedUsers
+    )
+    const value: PlutoGithubUsersResponse = { ...base, users }
+    cache.set(config.repo, { at: Date.now(), value })
+    return value
+  } catch (error) {
+    throw toHttpError(error, event)
+  }
+}

package/modules/pluto-github/runtime/server/utils/local-git-routes.ts

@@ -0,0 +1,95 @@
+import type { H3Event } from 'h3'
+import type { LocalGitStatus } from '../store/local-git'
+import { createError, setResponseHeader } from 'h3'
+import { createPlutoError } from '../../../../../server/utils/pluto-error'
+import {
+  LocalPushFailure,
+  pushLocalGit,
+  readLocalGitStatus,
+} from '../store/local-git'
+import { getGithubConfig } from './github-config'
+import { isLocalRequest } from './session'
+
+/**
+ * The local Git routes exist for local mode only: a dev build, the `fs` store, and a request from
+ * this machine (the rule of the dev local user). Any other request gets 404, so the routes say
+ * nothing about the repo.
+ */
+function localRoot(event: H3Event): string {
+  setResponseHeader(event, 'Cache-Control', 'no-store')
+  const config = getGithubConfig()
+  if (
+    !config.dev ||
+    config.storage !== 'fs' ||
+    !config.fsRoot ||
+    !isLocalRequest(event)
+  ) {
+    throw createError({ statusCode: 404 })
+  }
+  return config.fsRoot
+}
+
+/** Route: GET /api/_pluto/github/local/status. The branch and the commits that are not pushed. */
+export async function handleLocalGitStatus(
+  event: H3Event
+): Promise<LocalGitStatus> {
+  return readLocalGitStatus(localRoot(event))
+}
+
+const PUSH_ERRORS: Record<
+  LocalPushFailure['reason'],
+  { statusCode: number; message: string; key: string }
+> = {
+  'not-a-repo': {
+    statusCode: 409,
+    message: 'The project is not a Git repo.',
+    key: 'notARepo',
+  },
+  detached: {
+    statusCode: 409,
+    message: 'Git is not on a branch.',
+    key: 'detached',
+  },
+  'no-remote': {
+    statusCode: 409,
+    message: 'The repo has no remote.',
+    key: 'noRemote',
+  },
+  rejected: {
+    statusCode: 409,
+    message: 'The remote has commits that this repo does not have. Pull first.',
+    key: 'rejected',
+  },
+  auth: {
+    statusCode: 502,
+    message: 'Git could not sign in to the remote.',
+    key: 'auth',
+  },
+  timeout: {
+    statusCode: 504,
+    message: 'The push took too long.',
+    key: 'timeout',
+  },
+  failed: { statusCode: 502, message: 'Git could not push.', key: 'failed' },
+}
+
+/** Route: POST /api/_pluto/github/local/push. Pushes the current branch, then answers the status. */
+export async function handleLocalGitPush(
+  event: H3Event
+): Promise<LocalGitStatus> {
+  const root = localRoot(event)
+  try {
+    return await pushLocalGit(root)
+  } catch (error) {
+    if (!(error instanceof LocalPushFailure)) {
+      throw error
+    }
+    const known = PUSH_ERRORS[error.reason]
+    throw createPlutoError({
+      statusCode: known.statusCode,
+      message: known.message,
+      key: `pluto.github.local.errors.${known.key}`,
+      data: { reason: error.reason },
+    })
+  }
+}

package/modules/pluto-github/runtime/shared/build-status.ts

@@ -245,6 +245,32 @@ export function reduceBuildStatus(sources: BuildStatusSources): {
   return { state: reduceBuildState(items), items }
 }
 
+/**
+ * True when a commit message asks CI not to run: `[skip ci]`, `[ci skip]`, `[no ci]`,
+ * `[skip actions]` or `[actions skip]`, in any case. GitHub Actions reads the same markers. A draft
+ * save of the Git CMS gets `[skip ci]`.
+ */
+export function hasSkipMarker(message: unknown): boolean {
+  return (
+    typeof message === 'string' &&
+    /\[(?:skip ci|ci skip|no ci|skip actions|actions skip)\]/i.test(message)
+  )
+}
+
+/**
+ * The commit whose builds the edit form shows: the newest commit that does not skip CI, from a
+ * list of commits, newest first. A draft save skips the deploy, so the build of the last real
+ * change still tells the state of the site. With no such commit, the newest one.
+ */
+export function pickDeployCommit<
+  T extends { commit?: { message?: string } | null },
+>(commits: readonly T[]): T | undefined {
+  return (
+    commits.find((commit) => !hasSkipMarker(commit.commit?.message)) ??
+    commits[0]
+  )
+}
+
 /** The first line of a commit message, cut to 200 characters. */
 export function commitHeadline(message: unknown): string {
   const first =