@plutocms/core 0.47.0 → 0.48.0

package/modules/pluto-github/index.ts

@@ -55,6 +55,16 @@ export default defineNuxtModule<PlutoGithubOptions>({
         return meta?.name === 'supabase' || meta?.plutoBackend === true
       }) || modules.includes('@nuxtjs/supabase')
 
+    // A static build (`nuxt generate`, or a static Nitro preset such as `github_pages`): the pages
+    // are prerendered from the files of the checkout. The output has no server, so the module adds
+    // no sign-in, admin or write route.
+    // `_generate` is the internal flag of `nuxt generate`. It is not in the public types.
+    const generate = (nuxt.options as { _generate?: boolean })._generate
+    const isStatic =
+      !nuxt.options.dev &&
+      (Boolean(generate || nuxt.options.nitro?.static) ||
+        isStaticPreset(nuxt.options.nitro?.preset ?? process.env.NITRO_PRESET))
+
     const { enabled, resolved, warnings, errors } = resolvePlutoGithubOptions(
       options,
       {
@@ -65,6 +75,7 @@ export default defineNuxtModule<PlutoGithubOptions>({
         gitOrigin: nuxt.options.dev
           ? readGitOrigin(nuxt.options.rootDir)
           : undefined,
+        static: isStatic,
       }
     )
 
@@ -98,7 +109,8 @@ export default defineNuxtModule<PlutoGithubOptions>({
     Object.assign(secrets, {
       apiUrl: resolved.github.apiUrl,
       skipDeploy: resolved.commit.skipDeploy,
-      localCommit: resolved.commit.local,
+      // A static build only reads.
+      localCommit: resolved.commit.local && !isStatic,
       headTtl: resolved.cache.headTtl,
       cacheStorage: resolved.cache.storage,
       postType: resolved.postType,
@@ -118,6 +130,8 @@ export default defineNuxtModule<PlutoGithubOptions>({
       dir: resolved.dir,
       postType: resolved.postType,
       skipDeploy: resolved.commit.skipDeploy,
+      // A static build has no server: the client asks for no session.
+      static: isStatic,
     }
     // The media library of core uses the GitHub driver (runtime/server/media.ts).
     const media = nuxt.options.runtimeConfig.public.plutoMedia as
@@ -129,31 +143,55 @@ export default defineNuxtModule<PlutoGithubOptions>({
 
     const resolver = createResolver(import.meta.url)
     const server = (file: string) => resolver.resolve('./runtime/server', file)
+    // A route of the server build. A static build has no server, so it adds none.
+    const addRoute = (route: string, method: 'get' | 'post', file: string) => {
+      if (!isStatic) {
+        addServerHandler({ route, method, handler: server(file) })
+      }
+    }
 
-    // Server: the sign-in routes, and the Nitro plugin that
-    // registers the store, the adapter and the post type.
-    addServerHandler({
-      route: '/api/_pluto/auth/github/login',
-      method: 'get',
-      handler: server('api/auth/github/login.get'),
-    })
-    addServerHandler({
-      route: '/api/_pluto/auth/github/callback',
-      method: 'get',
-      handler: server('api/auth/github/callback.get'),
-    })
-    addServerHandler({
-      route: '/api/_pluto/auth/logout',
-      method: 'post',
-      handler: server('api/auth/logout.post'),
-    })
-    addServerHandler({
-      route: '/api/_pluto/auth/session',
-      method: 'get',
-      handler: server('api/auth/session.get'),
-    })
+    // The Nitro plugin registers the store, the adapter and the post type. A static build needs
+    // it too: the public API reads the files while the pages prerender.
     addServerPlugin(server('plugins/pluto-github'))
 
+    if (isStatic) {
+      // A project site of GitHub Pages lives under `/<repo>/`. The workflow gives the path in
+      // `PLUTO_BASE_URL`, and the module writes it in the build config and the app config.
+      // `NUXT_APP_BASE_URL` does not work here: the prerenderer reads it at run time too, the
+      // paths then do not match, and every page answers a redirect.
+      const basePath = process.env.PLUTO_BASE_URL?.trim()
+      if (basePath) {
+        const baseURL = normalizeBasePath(basePath)
+        nuxt.options.app.baseURL = baseURL
+        nuxt.options.runtimeConfig.app = {
+          ...nuxt.options.runtimeConfig.app,
+          baseURL,
+        }
+      }
+      // The admin, the API routes of the admin and the preview pages stay out of the output.
+      nuxt.options.nitro.prerender ||= {}
+      nuxt.options.nitro.prerender.ignore = [
+        ...(nuxt.options.nitro.prerender.ignore ?? []),
+        '/admin',
+        '/api/_pluto',
+        '/_pluto',
+      ]
+    }
+
+    // Server: the sign-in routes.
+    addRoute(
+      '/api/_pluto/auth/github/login',
+      'get',
+      'api/auth/github/login.get'
+    )
+    addRoute(
+      '/api/_pluto/auth/github/callback',
+      'get',
+      'api/auth/github/callback.get'
+    )
+    addRoute('/api/_pluto/auth/logout', 'post', 'api/auth/logout.post')
+    addRoute('/api/_pluto/auth/session', 'get', 'api/auth/session.get')
+
     // Client: the extension plugin and the session composable. Core owns the
     // admin routes, the login page and the route guard.
     addPlugin({ src: resolver.resolve('./runtime/app/plugins/pluto-github') })
@@ -183,10 +221,27 @@ export default defineNuxtModule<PlutoGithubOptions>({
     const settingsFile = resolver.resolve(
       '../../app/components/Pluto/Github/PlutoGithubSettingsPage.vue'
     )
+    // The Deploy tab of Settings (`/admin/settings/deploy`): the hosts, and GitHub Pages.
+    const deployFile = resolver.resolve(
+      '../../app/components/Pluto/Github/PlutoGithubDeployPage.vue'
+    )
+    // The Users page (`/admin/users`): the people with write access to the repo, read only.
+    const usersFile = resolver.resolve(
+      '../../app/components/Pluto/Github/PlutoGithubUsersPage.vue'
+    )
     extendPages((pages) => {
-      const settings = pages
-        .find((page) => page.path === '/admin')
-        ?.children?.find((page) => page.path === 'settings')
+      const admin = pages.find((page) => page.path === '/admin')
+      if (admin) {
+        admin.children ||= []
+        admin.children.push({
+          name: 'admin-users',
+          path: 'users',
+          file: usersFile,
+        })
+      } else {
+        logger.warn('Could not find the admin page. The Users page is off.')
+      }
+      const settings = admin?.children?.find((page) => page.path === 'settings')
       if (settings) {
         settings.children ||= []
         settings.children.push({
@@ -194,6 +249,11 @@ export default defineNuxtModule<PlutoGithubOptions>({
           path: 'github',
           file: settingsFile,
         })
+        settings.children.push({
+          name: 'admin-settings-deploy',
+          path: 'deploy',
+          file: deployFile,
+        })
       } else {
         logger.warn('Could not find the Settings page. The GitHub tab is off.')
       }
@@ -201,37 +261,36 @@ export default defineNuxtModule<PlutoGithubOptions>({
 
     // Setup routes: the checks and the App Manifest flow. See the git-cms skill.
     // They are static, so they win over the `:type/:slug` route below.
-    addServerHandler({
-      route: '/api/_pluto/github/setup/status',
-      method: 'get',
-      handler: server('api/setup/status.get'),
-    })
-    addServerHandler({
-      route: '/api/_pluto/github/setup/start',
-      method: 'get',
-      handler: server('api/setup/start.get'),
-    })
-    addServerHandler({
-      route: '/api/_pluto/github/setup/callback',
-      method: 'get',
-      handler: server('api/setup/callback.get'),
-    })
+    addRoute('/api/_pluto/github/setup/status', 'get', 'api/setup/status.get')
+    addRoute('/api/_pluto/github/setup/start', 'get', 'api/setup/start.get')
+    addRoute(
+      '/api/_pluto/github/setup/callback',
+      'get',
+      'api/setup/callback.get'
+    )
 
     // The build status of the head commit. It needs a signed-in user.
-    addServerHandler({
-      route: '/api/_pluto/github/build-status',
-      method: 'get',
-      handler: server('api/build-status.get'),
-    })
+    addRoute('/api/_pluto/github/build-status', 'get', 'api/build-status.get')
+
+    // The Deploy tab: the facts of the hosts (signed-in user), and the GitHub Pages setup (local
+    // mode on this computer only; the handler checks it).
+    addRoute('/api/_pluto/github/deploy/status', 'get', 'api/deploy/status.get')
+    addRoute('/api/_pluto/github/deploy/pages', 'post', 'api/deploy/pages.post')
+
+    // The people with write access to the repo, for the Users page. It needs a signed-in user.
+    addRoute('/api/_pluto/github/users', 'get', 'api/users.get')
+
+    // Local mode: the Git state of the project and the Push button of the backend badge.
+    // A dev build with the `fs` store only. The handlers also check the request.
+    if (nuxt.options.dev && resolved.storage === 'fs') {
+      addRoute('/api/_pluto/github/local/status', 'get', 'api/local/status.get')
+      addRoute('/api/_pluto/github/local/push', 'post', 'api/local/push.post')
+    }
 
     // The public reads of the posts go through the public API of core (`/api/pluto/v1/content/post`).
 
     // The media files that are in the repo but not in a deploy yet. See the media skill.
-    addServerHandler({
-      route: '/media/**',
-      method: 'get',
-      handler: server('routes/media.get'),
-    })
+    addRoute('/media/**', 'get', 'routes/media.get')
 
     logger.info(
       `Standalone CMS on. Storage: ${resolved.storage}. Dir: ${resolved.dir}.`
@@ -245,3 +304,20 @@ function toCamelCase(name: string): string {
     .toLowerCase()
     .replace(/_([a-z])/g, (_match, char: string) => char.toUpperCase())
 }
+
+/** The Nitro presets that write only static files: `static`, `github_pages`, `*_static`. */
+export function isStaticPreset(preset: unknown): boolean {
+  if (typeof preset !== 'string') {
+    return false
+  }
+  const name = preset.toLowerCase().replaceAll('-', '_')
+  return (
+    name === 'static' || name === 'github_pages' || name.endsWith('_static')
+  )
+}
+
+/** `repo`, `/repo` and `/repo/` become `/repo/`. An empty path becomes `/`. */
+export function normalizeBasePath(path: string): string {
+  const segments = path.split('/').filter(Boolean)
+  return segments.length > 0 ? `/${segments.join('/')}/` : '/'
+}

package/modules/pluto-github/options.ts

@@ -7,12 +7,15 @@ export interface PlutoGithubOptions {
    * `false` turns it off.
    */
   enabled?: boolean | 'auto'
-  /** Where the posts live. `fs` is valid in dev only. Default `fs` in dev, `github` in production. */
+  /**
+   * Where the posts live. `fs` is valid in dev and in a static build only. Default `fs` in dev and
+   * in a static build (`nuxt generate`), `github` in a server build.
+   */
   storage?: 'github' | 'fs'
   github?: {
     /**
      * The repo as `owner/name`. Required when storage is `github`. Default: the env var
-     * `NUXT_PLUTO_GITHUB_REPO` or `PLUTO_GITHUB_REPO`, then Vercel's repo, then (dev only)
+     * `NUXT_PLUTO_GITHUB_REPO` or `PLUTO_GITHUB_REPO`, then Vercel's repo, then Netlify's repo, then (dev only)
      * the `origin` remote of the local git repo.
      */
     repo?: string
@@ -72,6 +75,11 @@ export interface PlutoGithubResolveContext {
   env?: Record<string, string | undefined>
   /** The URL of the `origin` git remote. The module reads it in dev only. */
   gitOrigin?: string
+  /**
+   * A static build (`nuxt generate`): the site reads the content from the files of the checkout
+   * while it prerenders. The `fs` store is the default and is valid. No sign-in, no admin.
+   */
+  static?: boolean
 }
 
 export interface PlutoGithubResolveResult {
@@ -137,7 +145,7 @@ export function resolvePlutoGithubOptions(
       options.storage ??
       (fromEnv('PLUTO_GITHUB_STORAGE') as
         ResolvedPlutoGithubOptions['storage'] | undefined) ??
-      (ctx.dev ? 'fs' : 'github'),
+      (ctx.dev || ctx.static ? 'fs' : 'github'),
     github: {
       repo: options.github?.repo || detectRepo(ctx, fromEnv),
       branch: options.github?.branch ?? 'main',
@@ -185,9 +193,9 @@ export function resolvePlutoGithubOptions(
     errors.push(
       `plutoGithub.storage must be "github" or "fs". Got "${String(resolved.storage)}".`
     )
-  } else if (resolved.storage === 'fs' && !ctx.dev) {
+  } else if (resolved.storage === 'fs' && !ctx.dev && !ctx.static) {
     errors.push(
-      'plutoGithub.storage "fs" works in dev only. Use "github" for a build.'
+      'plutoGithub.storage "fs" works in dev and in a static build (nuxt generate) only. Use "github" for a server build.'
     )
   } else if (resolved.storage === 'github' && !resolved.github.repo) {
     errors.push(
@@ -238,6 +246,11 @@ function detectRepo(
   if (owner && slug) {
     return `${owner}/${slug}`
   }
+  // Netlify gives the URL of the repo to the build.
+  const netlify = parseGithubRepoUrl(fromEnv('REPOSITORY_URL') ?? '')
+  if (netlify) {
+    return netlify
+  }
   return ctx.dev && ctx.gitOrigin
     ? (parseGithubRepoUrl(ctx.gitOrigin) ?? '')
     : ''

package/modules/pluto-github/runtime/app/composables/pluto-github-local-git.ts

@@ -0,0 +1,50 @@
+import type { LocalGitStatus } from '../../server/store/local-git'
+import { computed } from 'vue'
+import { useState } from '#imports'
+
+export type { LocalGitStatus }
+
+export const CMS_LOCAL_STATUS_URL = '/api/_pluto/github/local/status'
+export const CMS_LOCAL_PUSH_URL = '/api/_pluto/github/local/push'
+
+/**
+ * The local Git repo of the project in local mode (`fs` store, dev): the branch and the commits
+ * that are not pushed. The state is shared under one key. It is `null` until the first read, and
+ * after a failed read. The CMS plugin reads it again on each admin navigation, when the tab shows
+ * again, and every 15 seconds while an admin page shows.
+ */
+export function usePlutoGithubLocalGit() {
+  const status = useState<LocalGitStatus | null>(
+    'pluto-github-local-git',
+    () => null
+  )
+  const pushing = useState('pluto-github-local-git-pushing', () => false)
+
+  async function refresh(): Promise<void> {
+    try {
+      status.value = await $fetch<LocalGitStatus>(CMS_LOCAL_STATUS_URL)
+    } catch {
+      status.value = null
+    }
+  }
+
+  /** Pushes the branch. Throws the fetch error, so the caller can show it. */
+  async function push(): Promise<void> {
+    pushing.value = true
+    try {
+      status.value = await $fetch<LocalGitStatus>(CMS_LOCAL_PUSH_URL, {
+        method: 'POST',
+      })
+    } finally {
+      pushing.value = false
+    }
+  }
+
+  return {
+    status,
+    pushing,
+    ahead: computed(() => (status.value?.repo ? status.value.ahead : 0)),
+    refresh,
+    push,
+  }
+}

package/modules/pluto-github/runtime/app/composables/pluto-github-session.ts

@@ -1,5 +1,5 @@
 import { computed } from 'vue'
-import { useFetch, useRequestFetch } from '#imports'
+import { useFetch, useRequestFetch, useRuntimeConfig } from '#imports'
 
 export const CMS_SESSION_URL = '/api/_pluto/auth/session'
 export const CMS_LOGOUT_URL = '/api/_pluto/auth/logout'
@@ -26,11 +26,18 @@ export interface PlutoGithubSessionResponse {
  * The browser fetches it after hydration (`server: false`). The server never
  * reads it, so a public page that a CDN caches never holds a user. The admin
  * is client-only, so it loses nothing. The response has no token.
+ *
+ * A static build (`public.plutoGithub.static`) has no server, so it never asks: nobody is
+ * signed in there.
  */
 export function usePlutoGithubSession() {
+  const isStatic =
+    (useRuntimeConfig().public.plutoGithub as { static?: boolean } | undefined)
+      ?.static === true
   const asyncData = useFetch<PlutoGithubSessionResponse>(CMS_SESSION_URL, {
     key: 'pluto-github-session',
     server: false,
+    immediate: !isStatic,
     $fetch: useRequestFetch(),
     default: () => ({ user: null }),
   })

package/modules/pluto-github/runtime/app/plugins/pluto-github.ts

@@ -1,7 +1,8 @@
 import type { PlutoGithubSessionResponse } from '../composables/pluto-github-session'
 import { defineAsyncComponent } from 'vue'
-import { defineNuxtPlugin, useRuntimeConfig } from '#imports'
+import { defineNuxtPlugin, useRouter, useRuntimeConfig } from '#imports'
 import PlutoGithubSignIn from '../../../../../app/components/Pluto/Github/PlutoGithubSignIn.vue'
+import { isAdminPath } from '../../../../../app/composables/internal/admin-shell'
 import { definePlutoExtension } from '../../../../../app/composables/pluto-extension'
 import { usePlutoRegistry } from '../../../../../app/composables/pluto-registry'
 import {
@@ -10,11 +11,21 @@ import {
   showPublicRepoWarning,
 } from '../../shared/client-rules'
 import { plutoGithubPostType } from '../../shared/post-type'
+import { usePlutoGithubLocalGit } from '../composables/pluto-github-local-git'
 import {
   CMS_SESSION_URL,
   usePlutoGithubSession,
 } from '../composables/pluto-github-session'
 
+// The popover of the backend badge. It loads when the popover opens.
+const PlutoGithubBackendDetails = defineAsyncComponent(
+  () =>
+    import('../../../../../app/components/Pluto/Github/PlutoGithubBackendDetails.vue')
+)
+
+/** How often the badge reads the local repo again while an admin page shows. */
+const LOCAL_GIT_INTERVAL = 15_000
+
 // The dashboard loads each widget on demand, with a skeleton.
 const PlutoGithubPublicRepoWarning = defineAsyncComponent(
   () =>
@@ -51,6 +62,16 @@ export default defineNuxtPlugin(() => {
       | undefined
   )
 
+  // Local mode: the saves are commits in the local repo. The badge counts the commits that are
+  // not pushed. The status route exists in this mode only.
+  const local =
+    (useRuntimeConfig().public.plutoGithub as { storage?: string } | undefined)
+      ?.storage === 'fs'
+  const localGit = usePlutoGithubLocalGit()
+  if (local && import.meta.client) {
+    watchLocalGit(localGit.refresh)
+  }
+
   const { read, write, delete: remove } = plutoGithubPostType.capabilities ?? {}
   const capabilities = (
     postType
@@ -105,6 +126,35 @@ export default defineNuxtPlugin(() => {
       signInTitle: 'pluto.github.login.title',
       signInDescription: 'pluto.github.login.description',
     },
+    // The Users item of the menu, between Media (900) and Settings (1000). The page
+    // (`/admin/users`, added by the module) lists the people with write access to the repo.
+    nav: [
+      {
+        id: 'users',
+        order: 950,
+        label: 'pluto.github.users.title',
+        icon: 'i-lucide-users',
+        to: '/admin/users',
+      },
+    ],
+
+    // The backend badge of the navbar: local files with Git, or a GitHub repo.
+    backend: {
+      id: 'git',
+      kind: 'git',
+      label: local
+        ? 'pluto.github.backend.local'
+        : 'pluto.github.backend.github',
+      icon: local ? 'i-lucide-hard-drive' : 'i-pluto-github',
+      count: () => (local ? localGit.ahead.value : 0),
+      countLabel: 'pluto.github.local.aheadShort',
+      details: PlutoGithubBackendDetails,
+      onOpen: () => {
+        if (local) {
+          localGit.refresh()
+        }
+      },
+    },
     // The GitHub tab of Settings: the setup check and the Create button. The module
     // adds its route (`/admin/settings/github`) with `extendPages`.
     settingsPages: [
@@ -115,6 +165,14 @@ export default defineNuxtPlugin(() => {
         icon: 'pluto:github',
         to: '/admin/settings/github',
       },
+      // The Deploy tab: put the site on a host. The module adds its route too.
+      {
+        id: 'deploy',
+        order: 160,
+        label: 'pluto.settings.tabs.deploy',
+        icon: 'i-lucide-rocket',
+        to: '/admin/settings/deploy',
+      },
     ],
     // The content type gives the Posts nav item, the list and the form.
     contentTypes: postType ? [{ id: 'post', type: plutoGithubPostType }] : [],
@@ -169,3 +227,28 @@ export default defineNuxtPlugin(() => {
     },
   })
 })
+
+/**
+ * Reads the local repo on each admin navigation, when the tab shows again, and every
+ * `LOCAL_GIT_INTERVAL` while an admin page shows. A save commits on the server, so the count
+ * follows within that time, or at once on the next navigation.
+ */
+let watchingLocalGit = false
+
+function watchLocalGit(refresh: () => Promise<void>): void {
+  if (watchingLocalGit) {
+    return
+  }
+  watchingLocalGit = true
+  const router = useRouter()
+  const onAdmin = () => isAdminPath(router.currentRoute.value.path)
+  const tick = () => {
+    if (onAdmin() && document.visibilityState === 'visible') {
+      refresh()
+    }
+  }
+  router.afterEach(tick)
+  document.addEventListener('visibilitychange', tick)
+  setInterval(tick, LOCAL_GIT_INTERVAL)
+  tick()
+}

package/modules/pluto-github/runtime/server/adapter.ts

@@ -52,6 +52,10 @@ export interface MarkdownContentAdapterOptions {
   /** Reads the caller of a request. `null` means anonymous. */
   getAccess: (event: H3Event) => Promise<PlutoGithubAccess | null>
   commit?: {
+    /**
+     * `true`: every commit gets `[skip ci]`. `false`: only a commit that changes no published
+     * content gets it (a draft that stays a draft), so a draft save starts no deploy.
+     */
     skipDeploy?: boolean
   }
   /** The cache that holds parsed files by blob id. A memory cache by default. */
@@ -183,7 +187,7 @@ export function createMarkdownContentAdapter(
   const cache = options.cache ?? createGithubCache({ headTtl: 0 })
   const retries = options.retries ?? 2
   const now = options.now ?? (() => new Date())
-  const skipSuffix = options.commit?.skipDeploy ? ' [skip ci]' : ''
+  const skipAll = options.commit?.skipDeploy === true
 
   // --- Errors ---------------------------------------------------------------
 
@@ -469,7 +473,7 @@ export function createMarkdownContentAdapter(
   function isPublished(
     type: PlutoContentType,
     layout: Layout,
-    entry: Entry
+    entry: Pick<Entry, 'frontmatter'>
   ): boolean {
     if (!layout.statusColumn) {
       return true
@@ -535,8 +539,17 @@ export function createMarkdownContentAdapter(
 
   // --- Writes ---------------------------------------------------------------
 
-  function messageOf(type: PlutoContentType, verb: string): string {
-    return `content(${type.name}): ${verb}${skipSuffix}`
+  /**
+   * The commit message. `publicChange` is false when the commit changes no published content:
+   * the item is a draft before and after. Such a commit gets `[skip ci]`, so it starts no deploy.
+   */
+  function messageOf(
+    type: PlutoContentType,
+    verb: string,
+    publicChange: boolean
+  ): string {
+    const skip = skipAll || !publicChange ? ' [skip ci]' : ''
+    return `content(${type.name}): ${verb}${skip}`
   }
 
   /** Runs a plan against a fresh head. Retries when only unrelated files changed. */
@@ -859,6 +872,8 @@ export function createMarkdownContentAdapter(
 
       const frontmatter: Record<string, unknown> = {}
       applyValues(type, layout, frontmatter, values, 'create')
+      // A published item (or a type with no status) is public: its commit starts a deploy.
+      const published = isPublished(type, layout, { frontmatter })
       if (
         layout.statusColumn &&
         frontmatter[layout.statusColumn] === layout.publishedValue
@@ -874,7 +889,7 @@ export function createMarkdownContentAdapter(
           throw slugTakenError(slug)
         }
         return {
-          message: messageOf(type, `create "${slug}"`),
+          message: messageOf(type, `create "${slug}"`, published),
           additions: [{ path, contents: text }],
           deletions: [],
           targets: [{ path, oid: null }],
@@ -982,7 +997,7 @@ export function createMarkdownContentAdapter(
           verb = `${nowPublished ? 'publish' : 'unpublish'} "${oldSlug}"`
         }
         return {
-          message: messageOf(type, verb),
+          message: messageOf(type, verb, wasPublished || nowPublished),
           additions: [{ path: newPath, contents: text }],
           deletions: newPath === oldPath ? [] : [{ path: oldPath }],
           targets,
@@ -1018,7 +1033,11 @@ export function createMarkdownContentAdapter(
           throw notFoundError()
         }
         return {
-          message: messageOf(type, `delete "${slug}"`),
+          message: messageOf(
+            type,
+            `delete "${slug}"`,
+            isPublished(type, layout, current)
+          ),
           additions: [],
           deletions: [{ path }],
           targets: [{ path, oid: current.oid }],

package/modules/pluto-github/runtime/server/api/deploy/pages.post.ts

@@ -0,0 +1,5 @@
+import { defineEventHandler } from 'h3'
+import { handleSetupPages } from '../../utils/deploy'
+
+/** Route: POST /api/_pluto/github/deploy/pages. Local mode only: the Pages workflow and gh. */
+export default defineEventHandler(handleSetupPages)

package/modules/pluto-github/runtime/server/api/deploy/status.get.ts

@@ -0,0 +1,5 @@
+import { defineEventHandler } from 'h3'
+import { handleDeployStatus } from '../../utils/deploy'
+
+/** Route: GET /api/_pluto/github/deploy/status. The facts of the Deploy page. */
+export default defineEventHandler(handleDeployStatus)

package/modules/pluto-github/runtime/server/api/local/push.post.ts

@@ -0,0 +1,5 @@
+import { defineEventHandler } from 'h3'
+import { handleLocalGitPush } from '../../utils/local-git-routes'
+
+/** Route: POST /api/_pluto/github/local/push. Local mode only. */
+export default defineEventHandler(handleLocalGitPush)

package/modules/pluto-github/runtime/server/api/local/status.get.ts

@@ -0,0 +1,5 @@
+import { defineEventHandler } from 'h3'
+import { handleLocalGitStatus } from '../../utils/local-git-routes'
+
+/** Route: GET /api/_pluto/github/local/status. Local mode only. */
+export default defineEventHandler(handleLocalGitStatus)

package/modules/pluto-github/runtime/server/api/users.get.ts

@@ -0,0 +1,5 @@
+import { defineEventHandler } from 'h3'
+import { handleGithubUsers } from '../utils/github-users'
+
+/** Route: GET /api/_pluto/github/users. The people with write access to the repo. */
+export default defineEventHandler(handleGithubUsers)

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

@@ -323,7 +323,10 @@ export function createGithubStore(
         )
         return new Uint8Array(result.data)
       } catch (error) {
-        if (error instanceof PlutoGithubStoreError && error.code === 'not-found') {
+        if (
+          error instanceof PlutoGithubStoreError &&
+          error.code === 'not-found'
+        ) {
           return null
         }
         throw error