kennel 0.2.3 → 0.2.6

package/kernel/plugins/mail/SKILL.md

@@ -1,97 +0,0 @@
----
-name: kennel-mail
-description: Open and read local MailOS email drafts for a Kennel folder — Markdown draft files in `~/.email/drafts` with YAML frontmatter, filtered to drafts whose `folder` is the viewed folder or one of its subfolders. Use when the user asks to view drafts for a folder in the Kennel viewer, read mail drafts by subject, status, tags, or recipient, list which drafts belong to a workspace, open a specific draft, or see a draft's excerpt and revision.
----
-
-# Kennel Mail Plugin
-
-The Mail plugin (`@raggle-ai/mail`) shows local MailOS email drafts —
-Markdown files with YAML frontmatter in `~/.email/drafts/*.md` — scoped to the
-folder the user is viewing. It offers a folder selector, a draft list, and a
-per-draft detail view, without invoking the MailOS binary.
-
-This skill covers the agent-facing parts of that plugin: where drafts live,
-which drafts are visible for a folder, and how to open and verify the view.
-For the plugin package's implementation contract, see `plugins/README.md`
-in the Kennel repo.
-
-## When to use
-
-- The user asks to open, list, or read email drafts for a folder in Kennel.
-- The user wants to know which drafts belong to a workspace, or see a draft's
-  subject, status, tags, recipients, excerpt, or revision.
-- Preview or verification work needs the Mail plugin tab to be available and
-  populated for a target folder.
-
-## Workflow
-
-1. **Identify the folder** whose drafts the user wants. The mail plugin shows
-   only drafts whose `folder` frontmatter value is that folder itself or a
-   real subfolder of it (checked through `realpath`, so symlink escapes and
-   sibling paths are rejected).
-2. **Check for drafts.** Drafts live in `~/.email/drafts/` as `<id>.md`
-   files. Open the folder in the viewer and confirm the **Mail** plugin tab
-   appears; the tab only appears when at least one active draft belongs to the
-   folder, and its badge shows the draft count.
-3. **Read the drafts.** Each draft is Markdown with YAML frontmatter followed
-   by the message body. Only drafts with a non-empty `id` and an active status
-   (`working` or `ready`) are listed — sent and canceled drafts are excluded,
-   even though MailOS keeps them in the same directory. Read values from the
-   files; do not invent recipients or subjects.
-4. **Open the view.** `kennel serve <folder>` (or `kennel view <folder>` in a
-   source checkout), then point at the Mail tab. Launch, port, watch, and
-   link verification mechanics come from the `kennel-preview` skill — install
-   it alongside this one so the full workflow works.
-5. **Verify before reporting.** Confirm the server is alive
-   (`curl -fsS "$URL/api/health"`), the printed URL serves the exact requested
-   folder root, and confirm the specific drafts the user asked about are in
-   the draft directory with an active status and the matching `folder` value.
-
-## Content shape
-
-### Draft file location
-
-- Default mail directory: `~/.email/drafts/` (the server entry accepts a
-  `mailDir` override, intended for tests).
-- Each draft is `<id>.md`; ids are validated (no path separators, no `.`/`..`)
-  before a file is read.
-- Only files ending in `.md` are considered.
-
-### Draft frontmatter
-
-| Field                       | Meaning                                                                                           |
-| --------------------------- | ------------------------------------------------------------------------------------------------- |
-| `id`                        | Required for the draft to be listed                                                               |
-| `status`                    | `working` \| `ready` (active, listed) — sent/canceled/other are hidden                            |
-| `folder`                    | The folder this draft belongs to; must be the viewed folder or a real descendant (realpath check) |
-| `tags`                      | Array of strings                                                                                  |
-| `from`, `to`, `cc`, `bcc`   | Sender; recipient lists (a raw string is wrapped into a single-element list)                      |
-| `in_reply_to`, `references` | Reply threading                                                                                   |
-| `subject`                   | Subject line                                                                                      |
-| `created_at`, `updated_at`  | Timestamps; the list is sorted by `updatedAt` (falling back to `createdAt`) descending            |
-
-The YAML body after the frontmatter is the message body. The list item also
-carries an `excerpt` (first ~280 characters of the body) and a `revision` (a
-sha256 of the exact draft file bytes — MailOS treats this hash as the draft
-revision for guarded destructive actions).
-
-## Verification
-
-- Server alive: `curl -fsS --connect-timeout 3 --max-time 5 "$URL/api/health"`
-- Folder root: request `/api/documents` and confirm `root` is the requested
-  absolute folder.
-- Mail availability: the Mail plugin tab is present and its badge equals the
-  number of active drafts whose `folder` is inside the served folder.
-- Per-draft checks: draft ids, subjects, statuses, and `folder` values in the
-  view match the `~/.email/drafts/*.md` source files; drafts with status
-  `sent`/`canceled` or a `folder` outside the served root do not appear.
-
-## Boundaries
-
-- This plugin is read-only over the draft directory: it lists and renders
-  drafts. Composing, sending, or changing draft status is done through MailOS
-  itself (the `mailos` CLI), not this plugin.
-- Do not invent draft contents, recipients, or subjects — read them from the
-  files.
-- The mail view only exists inside the Kennel viewer (server + web app); the
-  `@raggle-ai/mail` package is not a standalone CLI.

package/kernel/plugins/mail/eslint.config.js

@@ -1,10 +0,0 @@
-import baseConfig from "@raggle-ai/eslint-config/base"
-import reactConfig from "@raggle-ai/eslint-config/react"
-
-export default [
-  ...baseConfig,
-  ...reactConfig,
-  {
-    ignores: ["dist/**", "**/_generated/", "vendor/**"],
-  },
-]

package/kernel/plugins/mail/src/api.ts

@@ -1,359 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http"
-
-import type { ApiRouteHandle } from "@raggle-ai/folder-plugin/endpoint"
-import type { MailosService } from "@raggle-ai/mail/mailos"
-import {
-  apiError,
-  jsonResponse,
-  parseJsonBody,
-  runApiRoute,
-} from "@raggle-ai/folder-plugin/endpoint"
-import {
-  deleteLocalDraftVerified,
-  MailAttachmentError,
-  MailDeleteError,
-  removeDraftAttachmentVerified,
-} from "@raggle-ai/mail/history"
-import {
-  createMailosService,
-  MailosCommandError,
-  MailSendFailure,
-} from "@raggle-ai/mail/mailos"
-import {
-  defaultMailDir,
-  isFolderWithin,
-  listMailForFolder,
-  readMailById,
-} from "@raggle-ai/mail/node"
-
-export type MailPreview = { body: string; signature: string | null }
-
-export type MailPreviewer = (options: {
-  folder: string
-  id: string
-  mail: NonNullable<Awaited<ReturnType<typeof readMailById>>>
-}) => Promise<MailPreview>
-
-/**
- * Context provided by the Vite plugin. `authorizeFolder` enforces the real
- * viewer root (realpath + locked root), `watch` wires folder live refresh,
- * and `mailPreviewer`/`mailDir`/`mailos` are test seams.
- */
-export type MailApiContext = {
-  authorizeFolder: (value: string | null) => string
-  mailDir?: string
-  mailos?: ReturnType<typeof createMailosService>
-  mailPreviewer?: MailPreviewer
-  watch: (folder: string) => void
-}
-
-type AuthorizedMail = {
-  folder: string
-  mail: NonNullable<Awaited<ReturnType<typeof readMailById>>> & {
-    folder: string
-  }
-}
-
-type Handler = ApiRouteHandle<MailApiContext>
-
-const defaultMailos = createMailosService()
-
-function defaultPreviewer(mailos: MailosService): MailPreviewer {
-  return async ({ mail }) => ({
-    body: mail.body,
-    // A no_signature draft sends without any signature; do not show one.
-    signature: mail.noSignature
-      ? null
-      : mail.folder
-        ? await mailos.signature(mail.folder)
-        : null,
-  })
-}
-
-function mailDirOption(mailDir?: string) {
-  return mailDir ?? defaultMailDir()
-}
-
-function requireString(value: unknown, name: string) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw apiError("bad-request", `Missing ${name} parameter`)
-  }
-  return value.trim()
-}
-
-function requireRevision(value: unknown) {
-  const revision = requireString(value, "revision")
-  if (!/^[a-f0-9]{64}$/i.test(revision)) {
-    throw apiError("bad-request", "Invalid revision parameter")
-  }
-  return revision.toLowerCase()
-}
-
-/**
- * Shared authorized read: the folder must be a real root/descendant of the
- * viewer root and the draft id must be a canonical filename with an active
- * MailOS status; the draft's recorded folder must really be within the
- * requested folder (symlink/traversal escapes collapse through realpath).
- */
-async function authorizedMail(
-  context: MailApiContext,
-  id: string,
-  pathValue: string | null,
-): Promise<AuthorizedMail> {
-  const trimmed = id.trim()
-  if (!trimmed) throw apiError("bad-request", "Missing id parameter")
-  const folder = context.authorizeFolder(pathValue)
-  const mail = await readMailById(trimmed, mailDirOption(context.mailDir))
-  if (!mail) throw apiError("not-found", "Mail not found")
-  if (!mail.folder) throw apiError("not-found", "Mail has no folder")
-  if (!isFolderWithin(folder, mail.folder)) {
-    throw apiError("not-found", "Mail not found for this folder")
-  }
-  return { folder, mail: { ...mail, folder: mail.folder } }
-}
-
-const listMail: Handler = async ({ context, query, response }) => {
-  const folder = context.authorizeFolder(query.get("path"))
-  const items = await listMailForFolder({
-    folder,
-    mailDir: mailDirOption(context.mailDir),
-  })
-  jsonResponse(response, 200, { folder, items })
-}
-
-const readItem: Handler = async ({ context, query, response }) => {
-  const id = requireString(query.get("id"), "id")
-  const { folder, mail } = await authorizedMail(context, id, query.get("path"))
-  context.watch(folder)
-
-  let preview: MailPreview
-  try {
-    const previewer =
-      context.mailPreviewer ?? defaultPreviewer(context.mailos ?? defaultMailos)
-    preview = await previewer({ id, folder, mail })
-  } catch (error) {
-    const detail =
-      error instanceof Error ? error.message : "Unknown preview error"
-    throw apiError("internal", `Mail preview failed: ${detail}`)
-  }
-
-  jsonResponse(response, 200, { mail, preview })
-}
-
-const resolveSender: Handler = async ({ context, query, response }) => {
-  const id = requireString(query.get("id"), "id")
-  const { mail } = await authorizedMail(context, id, query.get("path"))
-  const mailos = context.mailos ?? defaultMailos
-  const identity = await mailos.identity(mail.folder)
-  jsonResponse(response, 200, identity)
-}
-
-const readConversation: Handler = async ({
-  context,
-  query,
-  response,
-  signal,
-}) => {
-  const id = requireString(query.get("id"), "id")
-  const { mail } = await authorizedMail(context, id, query.get("path"))
-  const mailos = context.mailos ?? defaultMailos
-  const references = [...mail.references, mail.inReplyTo].filter(
-    (reference): reference is string => Boolean(reference),
-  )
-  const result = await mailos.conversation(mail.folder, references, signal)
-  jsonResponse(response, 200, result)
-}
-
-/**
- * Convert a CLI-level failure into a structured API error without leaking
- * command output: a hard child timeout is a 504, an aborted child is
- * rethrown for the endpoint's disconnect handling, and any other non-zero
- * exit becomes a generic 500 with a fixed message.
- */
-function commandFailureError(error: MailosCommandError): never {
-  if (error.timedOut || error.code === "timeout") {
-    throw apiError("timeout", "MailOS command timed out")
-  }
-  if (error.code === "aborted") throw error
-  throw apiError("failed", "MailOS command failed")
-}
-
-function sendFailureError(error: MailSendFailure) {
-  switch (error.reason) {
-    case "revision-match":
-      return apiError("conflict", error.message)
-    case "invalid-draft":
-      return apiError("bad-request", error.message)
-    case "unsupported-draft-dir":
-      return apiError("bad-request", error.message)
-    default:
-      return apiError("failed", error.message)
-  }
-}
-
-const runAction: Handler = async ({ body, context, response, signal }) => {
-  const parsed = parseJsonBody(body)
-  const action = requireString(parsed.action, "action")
-  const id = requireString(parsed.id, "id")
-  const revision = requireRevision(parsed.revision)
-  if (
-    action !== "archive" &&
-    action !== "delete" &&
-    action !== "remove-attachment"
-  ) {
-    throw apiError("bad-request", "Invalid action parameter")
-  }
-
-  const { mail } = await authorizedMail(context, id, pathFromParsed(parsed))
-  if (mail.revision !== revision) {
-    throw apiError("conflict", "Draft changed since it was loaded")
-  }
-
-  const mailos = context.mailos ?? defaultMailos
-  if (action === "remove-attachment") {
-    const attachment = requireString(parsed.attachment, "attachment")
-    try {
-      await removeDraftAttachmentVerified(
-        mail,
-        mailDirOption(context.mailDir),
-        attachment,
-      )
-    } catch (error) {
-      if (error instanceof MailAttachmentError) {
-        switch (error.outcome) {
-          case "missing":
-            throw apiError("not-found", error.message)
-          case "invalid":
-            throw apiError("bad-request", error.message)
-          case "changed":
-            throw apiError("conflict", error.message)
-        }
-      }
-      throw error
-    }
-  } else if (action === "delete") {
-    try {
-      await deleteLocalDraftVerified(mail, mailDirOption(context.mailDir))
-    } catch (error) {
-      if (error instanceof MailDeleteError) {
-        switch (error.outcome) {
-          case "missing":
-            throw apiError("not-found", error.message)
-          case "invalid":
-            throw apiError("bad-request", error.message)
-          case "changed":
-            throw apiError("conflict", error.message)
-        }
-      }
-      throw error
-    }
-  } else {
-    try {
-      await mailos.archive(mail.folder, mail.id, {
-        draftDir: mailDirOption(context.mailDir),
-        signal,
-      })
-    } catch (error) {
-      if (error instanceof MailSendFailure) throw sendFailureError(error)
-      if (error instanceof MailosCommandError) commandFailureError(error)
-      throw error
-    }
-  }
-
-  jsonResponse(response, 200, { action, id: mail.id, ok: true })
-}
-
-const runSend: Handler = async ({ body, context, response, signal }) => {
-  const parsed = parseJsonBody(body)
-  const id = requireString(parsed.id, "id")
-  const dryRun = parsed.dryRun === true
-  const { mail } = await authorizedMail(context, id, pathFromParsed(parsed))
-  const mailos = context.mailos ?? defaultMailos
-
-  if (dryRun) {
-    const preview = await mailos
-      .sendPreview(mail.folder, mail.id, {
-        draftDir: mailDirOption(context.mailDir),
-        signal,
-      })
-      .catch((error: unknown) => {
-        if (error instanceof MailSendFailure) throw sendFailureError(error)
-        if (error instanceof MailosCommandError) commandFailureError(error)
-        throw error
-      })
-    jsonResponse(response, 200, preview)
-    return
-  }
-
-  const revision = requireRevision(parsed.revision)
-  if (mail.revision !== revision) {
-    throw apiError("conflict", "Draft changed since it was loaded")
-  }
-  const result = await mailos
-    .confirmSend(mail.folder, mail.id, revision, {
-      draftDir: mailDirOption(context.mailDir),
-      signal,
-    })
-    .catch((error: unknown) => {
-      if (error instanceof MailSendFailure) throw sendFailureError(error)
-      if (error instanceof MailosCommandError) commandFailureError(error)
-      throw error
-    })
-  jsonResponse(response, 200, result)
-}
-
-function pathFromParsed(parsed: Record<string, unknown>) {
-  return typeof parsed.path === "string" && parsed.path ? parsed.path : null
-}
-
-/**
- * All mail HTTP routes. `/api/mail`, `/api/mail/item`, `/api/mail/from` and
- * `/api/mail/conversation` are GET-only reads (GET never mutates);
- * `/api/mail/action` and `/api/mail/send` are POST mutations guarded by the
- * endpoint wrapper's same-origin check. Returns false for non-mail paths so
- * the plugin can continue its own routing.
- */
-export async function handleMailApiRoutes(
-  request: IncomingMessage,
-  response: ServerResponse,
-  context: MailApiContext,
-): Promise<boolean> {
-  const url = new URL(request.url ?? "/", "http://127.0.0.1")
-
-  const specByPath: Record<
-    string,
-    {
-      method: "GET" | "POST"
-      maxBodyBytes?: number
-      timeoutMs?: number
-      handle: Handler
-    }
-  > = {
-    "/api/mail": { method: "GET", handle: listMail },
-    "/api/mail/item": { method: "GET", handle: readItem },
-    "/api/mail/from": { method: "GET", handle: resolveSender },
-    "/api/mail/conversation": {
-      method: "GET",
-      timeoutMs: 75_000,
-      handle: readConversation,
-    },
-    "/api/mail/action": {
-      method: "POST",
-      maxBodyBytes: 16 * 1024,
-      timeoutMs: 60_000,
-      handle: runAction,
-    },
-    "/api/mail/send": {
-      method: "POST",
-      maxBodyBytes: 16 * 1024,
-      timeoutMs: 90_000,
-      handle: runSend,
-    },
-  }
-
-  const spec = specByPath[url.pathname]
-  if (!spec) return false
-
-  await runApiRoute(request, response, url, spec, context)
-  return true
-}

package/kernel/plugins/mail/src/bun-ffi.d.ts

@@ -1,14 +0,0 @@
-/**
- * Ambient typing for the `bun:ffi` surface flock.ts uses. Bun's runtime
- * module provides `dlopen`; TypeScript cannot resolve it without this, and
- * flock.ts keeps the import dynamic so the Node (koffi) path never touches
- * bun's runtime.
- */
-declare module "bun:ffi" {
-  export function dlopen(
-    path: string,
-    symbols: Record<string, { args: string[]; returns: string }>,
-  ): {
-    symbols: Record<string, (...args: number[]) => number>
-  }
-}

package/kernel/plugins/mail/src/client.tsx

@@ -1,14 +0,0 @@
-import type { FolderPluginViewProps } from "@raggle-ai/folder-plugin/client"
-
-import { MailDetailPage } from "./mail-detail-page"
-import { MailPage } from "./mail-page"
-import { mailManifest } from "./manifest"
-
-export function MailPlugin(props: FolderPluginViewProps) {
-  return props.subpath ? <MailDetailPage {...props} /> : <MailPage {...props} />
-}
-
-export const mailClient = {
-  ...mailManifest,
-  component: MailPlugin,
-}

package/kernel/plugins/mail/src/flock.ts

@@ -1,137 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/triple-slash-reference -- ambient bun:ffi types for out-of-package consumers (packages/api compiles this file)
-/// <reference path="./bun-ffi.d.ts" />
-import { closeSync, constants, openSync } from "node:fs"
-import { mkdir } from "node:fs/promises"
-import { dirname, resolve } from "node:path"
-
-/**
- * Real POSIX advisory lock via `flock(2)` on MailOS-compatible lock files.
- *
- * MailOS (`emailos/internal/core/drafts.go` `withLocalDraftLock`) serializes
- * draft mutations with an exclusive `flock` on `<draftDir>/.locks/<base>.lock`
- * opened `O_CREATE|O_RDWR`. Kennel takes the *same* lock so destructive
- * actions (delete/archive critical sections) coordinate with the MailOS
- * binary itself, not just with other Kennel processes.
- *
- * Portability: `flock(2)` is reached through two supported FFI backends —
- * `bun:ffi` when the process runs on Bun (the test runner), and the `koffi`
- * N-API binding when it runs on Node (the Vite dev server / build). Both call
- * the exact same libc symbol on the exact same lock files, so coordination
- * holds across runtimes and against the Go MailOS binary. The wait is
- * bounded so an abandoned holder cannot hang a server request forever.
- */
-export class FlockTimeoutError extends Error {
-  readonly lockPath: string
-
-  constructor(lockPath: string, timeoutMs: number) {
-    super(
-      `Timed out after ${timeoutMs}ms waiting for the draft lock ${resolve(lockPath)}`,
-    )
-    this.name = "FlockTimeoutError"
-    this.lockPath = resolve(lockPath)
-  }
-}
-
-const LOCK_EX = 2
-const LOCK_NB = 4
-const LOCK_UN = 8
-const EINTR = 4
-const EWOULDBLOCK_DARWIN = 35
-const EWOULDBLOCK_LINUX = 11
-
-type FlockFn = (fd: number, operation: number) => number
-
-type FlockBackend = {
-  flock: FlockFn
-  /** Returns the last libc errno; only used on Node (koffi exposes it). */
-  errno: () => number
-}
-
-function isBunRuntime() {
-  return (
-    typeof process !== "undefined" &&
-    typeof process.versions !== "undefined" &&
-    "bun" in process.versions
-  )
-}
-
-const libcPath =
-  process.platform === "darwin" ? "/usr/lib/libSystem.B.dylib" : "libc.so.6"
-
-let backendPromise: Promise<FlockBackend> | null = null
-
-async function loadBackend(): Promise<FlockBackend> {
-  backendPromise ??= (async () => {
-    if (isBunRuntime()) {
-      // bun:ffi does not surface errno; a non-zero flock result on the just
-      // opened descriptor is treated as "held elsewhere" (would-block /
-      // EINTR) and retried until the bounded deadline, which is the only
-      // realistic outcome for a valid descriptor.
-      const { dlopen } = await import("bun:ffi")
-      const libc = dlopen(libcPath, {
-        flock: { args: ["int", "int"], returns: "int" },
-      })
-      return { flock: libc.symbols.flock as FlockFn, errno: () => 0 }
-    }
-    // Node: koffi exposes libc errno so would-block/EINTR can be told
-    // apart from a real locking error.
-    const koffi = (await import("koffi")).default
-    const libc = koffi.load(libcPath)
-    return {
-      flock: libc.func("int flock(int fd, int operation)"),
-      errno: koffi.errno,
-    }
-  })()
-  return backendPromise
-}
-
-const wouldBlockErrno =
-  process.platform === "darwin" ? EWOULDBLOCK_DARWIN : EWOULDBLOCK_LINUX
-
-function sleep(ms: number) {
-  return new Promise((resolveSleep) => {
-    setTimeout(resolveSleep, ms)
-  })
-}
-
-/**
- * Run `action` while holding an exclusive `flock` on `lockPath`. The file is
- * opened `O_RDWR|O_CREAT` (mode `0600`) exactly like MailOS; the lock is
- * released (and the descriptor closed) before `withFlock` resolves, so a
- * crash never leaves a stale advisory lock behind.
- */
-export async function withFlock<T>(
-  lockPath: string,
-  timeoutMs: number,
-  action: () => Promise<T>,
-): Promise<T> {
-  const resolved = resolve(lockPath)
-  // MailOS creates the lock directory with `os.MkdirAll(lockDir, 0o700)`.
-  await mkdir(dirname(resolved), { mode: 0o700, recursive: true }).catch(
-    () => undefined,
-  )
-  const { flock, errno } = await loadBackend()
-  const fd = openSync(resolved, constants.O_RDWR | constants.O_CREAT, 0o600)
-  try {
-    const deadline = Date.now() + timeoutMs
-    for (;;) {
-      if (flock(fd, LOCK_EX | LOCK_NB) === 0) break
-      const code = errno()
-      if (code !== 0 && code !== EINTR && code !== wouldBlockErrno) {
-        throw new Error(`flock failed on ${resolved} (errno ${code})`)
-      }
-      const remaining = deadline - Date.now()
-      if (remaining <= 0) {
-        throw new FlockTimeoutError(resolved, timeoutMs)
-      }
-      await sleep(Math.min(50, remaining))
-    }
-    return await action()
-  } finally {
-    try {
-      flock(fd, LOCK_UN)
-    } finally {
-      closeSync(fd)
-    }
-  }
-}

package/kernel/plugins/mail/src/folders.ts

@@ -1,37 +0,0 @@
-import type { FolderFilterChoice } from "@raggle-ai/ui/lib/folder-filter"
-import {
-  folderFilterChoices,
-  folderFilterLabel,
-} from "@raggle-ai/ui/lib/folder-filter"
-
-export type MailFolderChoice = FolderFilterChoice
-
-/**
- * Display text for a draft's owning folder relative to the viewed root:
- * basename for root-owned drafts ("example-workspace"), relative path for
- * descendants ("clients/client-one"). Null when the draft has no folder or it
- * does not live under the viewed root.
- *
- * Delegates to the shared folder-filter lib.
- */
-export function folderLabel(
-  folder: string | null,
-  rootFolder: string,
-): string | null {
-  return folderFilterLabel(folder, rootFolder)
-}
-
-/**
- * Exact owning-folder choices with per-draft counts for filtering the mail
- * list. Keyed by the full folder path so duplicate leaf names stay
- * distinct; ordered with the root folder first, then descendants
- * alphabetically by relative path.
- *
- * Delegates to the shared folder-filter lib.
- */
-export function folderChoices(
-  items: readonly { folder: string | null }[],
-  rootFolder: string,
-): MailFolderChoice[] {
-  return folderFilterChoices(items, rootFolder, (item) => item.folder)
-}