kennel 0.2.1 → 0.2.3

package/dist/site/server-plugins.js

@@ -6960,8 +6960,10 @@ var require_public_api = __commonJS((exports) => {
 });
 
 // packages/api/src/server/plugins.ts
-import { mkdir as mkdir3, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname6, resolve as resolve7, sep as sep6 } from "node:path";
+import { pathToFileURL } from "node:url";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir3, stat as stat4, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname7, resolve as resolve8, sep as sep7 } from "node:path";
 
 // packages/agents/src/manifest.ts
 var agentsManifest = {
@@ -8760,9 +8762,284 @@ function createMailPlugin({
   };
 }
 
+// packages/notes/src/server.ts
+import { readdir as readdir3, stat as stat2 } from "node:fs/promises";
+import { basename as basename3, extname, relative as relative3, resolve as resolve4, sep as sep4 } from "node:path";
+
+// packages/notes/src/manifest.ts
+var notesManifest = {
+  id: "notes",
+  label: "Notes"
+};
+
+// packages/notes/src/server.ts
+var markdownExtensions = new Set([".md", ".markdown"]);
+async function listMarkdownFiles(folder) {
+  const files = [];
+  const visit2 = async (current) => {
+    const entries = await readdir3(current, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name.startsWith("."))
+        continue;
+      const path = resolve4(current, entry.name);
+      if (entry.isDirectory()) {
+        await visit2(path);
+        continue;
+      }
+      if (!entry.isFile() || !markdownExtensions.has(extname(entry.name))) {
+        continue;
+      }
+      const details = await stat2(path).catch(() => {
+        return;
+      });
+      files.push({
+        activityAt: details?.mtimeMs ?? 0,
+        name: basename3(entry.name, extname(entry.name)),
+        relativePath: relative3(folder, path).split(sep4).join("/")
+      });
+    }
+  };
+  await visit2(folder);
+  return files.sort((left, right) => right.activityAt - left.activityAt);
+}
+async function loadNotes(folder, linkedFolders = []) {
+  const localFiles = await listMarkdownFiles(folder);
+  const linked = await Promise.all(linkedFolders.map(async (linkedFolder) => ({
+    files: await listMarkdownFiles(linkedFolder),
+    folder: linkedFolder
+  })));
+  return {
+    files: {
+      items: [
+        ...localFiles,
+        ...linked.flatMap((group) => group.files.map((file) => ({ ...file, folder: group.folder })))
+      ]
+    },
+    folder,
+    status: "available"
+  };
+}
+function createNotesPlugin() {
+  return {
+    ...notesManifest,
+    async detect({
+      folder
+    }) {
+      const files = await listMarkdownFiles(folder);
+      return files.length > 0 ? { count: files.length, status: "available" } : { status: "available" };
+    },
+    async handle({
+      folder,
+      linkedFolders
+    }) {
+      return { data: await loadNotes(folder, linkedFolders), kind: "available" };
+    }
+  };
+}
+
+// plugins/projects/src/server.ts
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname3, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// plugins/projects/src/manifest.ts
+var projectsManifest = {
+  id: "projects",
+  label: "Projects"
+};
+
+// plugins/projects/src/server.ts
+var scoutScript = `
+const local = require(process.argv[1]);
+(async () => {
+  const folder = process.argv[2];
+  const connected = await local.listConnectedProjects(folder, {
+    depth: 1,
+    focused: true,
+  });
+  process.stdout.write(JSON.stringify(local.connectedProjectsList(folder, connected)));
+})().catch(error => { console.error(error); process.exitCode = 1; });
+`;
+function resolveScoutModule() {
+  const require2 = createRequire2(import.meta.url);
+  const candidates = [];
+  try {
+    candidates.push(require2.resolve("@raggle-ai/local"));
+  } catch {}
+  let directory = dirname3(fileURLToPath(import.meta.url));
+  while (dirname3(directory) !== directory) {
+    if (existsSync(join(directory, "raggle.json"))) {
+      candidates.push(join(dirname3(directory), "raggle-ai-scout", "packages", "local"));
+      break;
+    }
+    directory = dirname3(directory);
+  }
+  for (const candidate of candidates) {
+    try {
+      const mod = require2(candidate);
+      if (typeof mod.listConnectedProjects === "function" && typeof mod.connectedProjectsList === "function") {
+        return candidate;
+      }
+    } catch {}
+  }
+  return;
+}
+function normalizeRepositories(raw) {
+  const repositories = [];
+  if (!Array.isArray(raw.repositories))
+    return repositories;
+  for (const value of raw.repositories) {
+    const row = value;
+    if (!row || typeof row !== "object" || typeof row.worktree !== "string")
+      continue;
+    const type = row.type;
+    const direction = row.direction;
+    if (type !== "dependency" && type !== "implementation" && type !== "notes" && type !== "related" || direction !== "incoming" && direction !== "outgoing" || typeof row.depth !== "number" || typeof row.repository !== "string" || row.worktree.length === 0)
+      continue;
+    repositories.push({
+      depth: row.depth,
+      direction,
+      repository: row.repository,
+      type,
+      worktree: row.worktree
+    });
+  }
+  return repositories;
+}
+function discoverProjects(scoutModule, folder) {
+  return new Promise((resolve5) => {
+    execFile(process.execPath, ["-e", scoutScript, scoutModule, folder], {
+      timeout: 60000,
+      maxBuffer: 8 * 1024 * 1024,
+      env: { ...process.env, NODE_OPTIONS: "" }
+    }, (error, stdout) => {
+      if (error) {
+        resolve5({
+          message: "Raggle Scout discovery timed out or failed. Retry the view to try again.",
+          projects: [],
+          status: "error"
+        });
+        return;
+      }
+      try {
+        const list = JSON.parse(stdout);
+        resolve5({
+          projects: normalizeRepositories(list),
+          status: "available"
+        });
+      } catch (parseError) {
+        resolve5({
+          message: `Could not parse the Scout response: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+          projects: [],
+          status: "error"
+        });
+      }
+    });
+  });
+}
+var TTL = 60000;
+var cache = new Map;
+var stamps = new Map;
+var inflight = new Map;
+var queue = Promise.resolve();
+function requestProjects(scoutModule, folder) {
+  const existing = inflight.get(folder);
+  if (existing)
+    return existing;
+  const run = queue.then(() => discoverProjects(scoutModule, folder), () => discoverProjects(scoutModule, folder));
+  queue = run.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  inflight.set(folder, run);
+  return run.finally(() => {
+    inflight.delete(folder);
+  });
+}
+async function loadProjects(context) {
+  const folder = context.folder;
+  const cached = cache.get(folder);
+  const stamp = stamps.get(folder) ?? 0;
+  if (cached && Date.now() - stamp < TTL)
+    return cached;
+  const scoutModule = resolveScoutModule();
+  if (cached && !scoutModule)
+    return cached;
+  if (scoutModule) {
+    const promise = requestProjects(scoutModule, folder);
+    if (cached) {
+      promise.then((load2) => {
+        if (load2.status === "available") {
+          cache.set(folder, load2);
+          stamps.set(folder, Date.now());
+        }
+      });
+      return cached;
+    }
+    const load = await promise;
+    if (load.status === "available") {
+      cache.set(folder, load);
+      stamps.set(folder, Date.now());
+    }
+    return load;
+  }
+  return {
+    message: "Raggle Scout module (@raggle-ai/local with connected-project discovery) could not be resolved.",
+    projects: [],
+    status: "error"
+  };
+}
+function createProjectsPlugin() {
+  return {
+    ...projectsManifest,
+    async detect(_context) {
+      return { status: "available" };
+    },
+    async handle(context, _subpath) {
+      const load = await loadProjects(context);
+      if (load.status === "error") {
+        return {
+          kind: "available",
+          data: {
+            folder: context.folder,
+            message: load.message,
+            projects: [],
+            status: "error"
+          }
+        };
+      }
+      return {
+        kind: "available",
+        data: {
+          folder: context.folder,
+          projects: load.projects,
+          status: "available"
+        }
+      };
+    }
+  };
+}
+
 // plugins/tasks/src/server.ts
-import { readdir as readdir3, readFile as readFile4, stat as stat2 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname3, relative as relative3, resolve as resolve4, sep as sep4 } from "node:path";
+import { readdir as readdir4, readFile as readFile4, stat as stat3 } from "node:fs/promises";
+import { basename as basename4, dirname as dirname4, relative as relative4, resolve as resolve5, sep as sep5 } from "node:path";
+
+// packages/folder-plugin/src/subpath.ts
+function matchSubpath(sources, subpath, itemsOf, matches) {
+  const id = subpath.trim();
+  if (!id)
+    return;
+  for (const source of sources) {
+    for (const item of itemsOf(source)) {
+      if (matches(item, id))
+        return { item, source };
+    }
+  }
+  return;
+}
 
 // plugins/tasks/src/data/parse.ts
 var TASK_TYPES = [
@@ -9188,26 +9465,26 @@ var tasksManifest = {
 // plugins/tasks/src/server.ts
 async function loadTaskSources(viewRoot, scanRoot = viewRoot) {
   const visit2 = async (current) => {
-    const entries = await readdir3(current, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir4(current, { withFileTypes: true }).catch(() => []);
     const paths2 = [];
     for (const entry of entries) {
       if (entry.isFile() && entry.name === "todo.json") {
-        paths2.push(resolve4(current, entry.name));
+        paths2.push(resolve5(current, entry.name));
         continue;
       }
       if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules")
         continue;
-      paths2.push(...await visit2(resolve4(current, entry.name)));
+      paths2.push(...await visit2(resolve5(current, entry.name)));
     }
     return paths2;
   };
-  const paths = (await visit2(scanRoot)).sort((left, right) => relative3(scanRoot, left).localeCompare(relative3(scanRoot, right)));
+  const paths = (await visit2(scanRoot)).sort((left, right) => relative4(scanRoot, left).localeCompare(relative4(scanRoot, right)));
   const issues = [];
   const warnings = [];
   const sources = [];
   await Promise.all(paths.map(async (path) => {
     const sourceText = await readFile4(path, "utf8");
-    const file = relative3(viewRoot, path).split(sep4).join("/");
+    const file = relative4(viewRoot, path).split(sep5).join("/");
     const parsed = parseTodoSource(sourceText);
     if (!parsed.ok) {
       issues.push({ file, problems: parsed.issues });
@@ -9217,12 +9494,12 @@ async function loadTaskSources(viewRoot, scanRoot = viewRoot) {
       file,
       problems: [
         ...todoFileWarnings(parsed.document),
-        ...await missingNoteIssues(parsed.document, dirname3(path))
+        ...await missingNoteIssues(parsed.document, dirname4(path))
       ]
     });
     sources.push({
       document: parsed.document,
-      folder: dirname3(path),
+      folder: dirname4(path),
       path: file
     });
   }));
@@ -9262,7 +9539,7 @@ async function missingNoteIssues(document, folder) {
       const target = (note.split("#", 1)[0] ?? "").trim();
       if (!target)
         continue;
-      const exists = await stat2(resolve4(folder, target)).then((entry) => entry.isFile()).catch(() => false);
+      const exists = await stat3(resolve5(folder, target)).then((entry) => entry.isFile()).catch(() => false);
       if (!exists) {
         missing.push({
           message: `references a missing note file: ${target}`,
@@ -9281,7 +9558,7 @@ function tasksOf(source) {
   return Array.isArray(source.document.tasks) ? source.document.tasks : [];
 }
 function sourceTitle(folder) {
-  return `${basename3(folder)} tasks`;
+  return `${basename4(folder)} tasks`;
 }
 function mergedDataset(folder, sources) {
   const root = sources.find((source) => source.path === "todo.json");
@@ -9444,19 +9721,17 @@ function createTasksPlugin() {
           };
         }
       }
-      for (const source of sources) {
-        const task = tasksOf(source).find((item) => item.id === id || item.key === id);
-        if (task) {
-          return {
-            kind: "available",
-            data: {
-              dataset: singleTaskDataset(context.folder, source, task),
-              folder: context.folder,
-              status: "available",
-              warnings
-            }
-          };
-        }
+      const bare = matchSubpath(sources, id, tasksOf, (item, target) => item.id === target || item.key === target);
+      if (bare) {
+        return {
+          kind: "available",
+          data: {
+            dataset: singleTaskDataset(context.folder, bare.source, bare.item),
+            folder: context.folder,
+            status: "available",
+            warnings
+          }
+        };
       }
       return {
         kind: "available",
@@ -9652,19 +9927,19 @@ import {
   unlink,
   writeFile
 } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute3, relative as relative4, resolve as resolve6, sep as sep5 } from "node:path";
+import { dirname as dirname6, isAbsolute as isAbsolute3, relative as relative5, resolve as resolve7, sep as sep6 } from "node:path";
 
 // plugins/mail/src/flock.ts
 import { closeSync, constants as constants2, openSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import { dirname as dirname4, resolve as resolve5 } from "node:path";
+import { dirname as dirname5, resolve as resolve6 } from "node:path";
 
 class FlockTimeoutError extends Error {
   lockPath;
   constructor(lockPath, timeoutMs) {
-    super(`Timed out after ${timeoutMs}ms waiting for the draft lock ${resolve5(lockPath)}`);
+    super(`Timed out after ${timeoutMs}ms waiting for the draft lock ${resolve6(lockPath)}`);
     this.name = "FlockTimeoutError";
-    this.lockPath = resolve5(lockPath);
+    this.lockPath = resolve6(lockPath);
   }
 }
 var LOCK_EX = 2;
@@ -9703,8 +9978,8 @@ function sleep(ms) {
   });
 }
 async function withFlock(lockPath, timeoutMs, action) {
-  const resolved = resolve5(lockPath);
-  await mkdir(dirname4(resolved), { mode: 448, recursive: true }).catch(() => {
+  const resolved = resolve6(lockPath);
+  await mkdir(dirname5(resolved), { mode: 448, recursive: true }).catch(() => {
     return;
   });
   const { flock, errno } = await loadBackend();
@@ -9752,15 +10027,15 @@ function draftRevision2(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
 async function ensureRealDirChain(anchor, childPath) {
-  const rel = relative4(anchor, childPath);
-  if (!rel || rel === ".." || rel.startsWith(`..${sep5}`) || isAbsolute3(rel)) {
+  const rel = relative5(anchor, childPath);
+  if (!rel || rel === ".." || rel.startsWith(`..${sep6}`) || isAbsolute3(rel)) {
     throw new MailDeleteError("invalid", "Lock/history path escapes the mail folder");
   }
   let current = anchor;
-  for (const segment of rel.split(sep5)) {
+  for (const segment of rel.split(sep6)) {
     if (!segment)
       continue;
-    current = resolve6(current, segment);
+    current = resolve7(current, segment);
     let info = await lstat2(current).catch(() => {
       return;
     });
@@ -9785,13 +10060,13 @@ async function deleteLocalDraftVerified(mail, mailDir) {
   if (!validDraftId(mail.id)) {
     throw new MailDeleteError("invalid", "Invalid mail id");
   }
-  const mailDirReal = await realpath3(resolve6(mailDir));
-  const target = resolve6(mail.filePath);
-  const targetDir = await realpath3(dirname5(target)).catch(() => null);
+  const mailDirReal = await realpath3(resolve7(mailDir));
+  const target = resolve7(mail.filePath);
+  const targetDir = await realpath3(dirname6(target)).catch(() => null);
   if (targetDir !== mailDirReal) {
     throw new MailDeleteError("invalid", "Draft path is outside the mail folder");
   }
-  const expected = resolve6(mailDirReal, `${mail.id.trim()}.md`);
+  const expected = resolve7(mailDirReal, `${mail.id.trim()}.md`);
   const targetReal = await realpath3(target).catch(() => null);
   if (targetReal === null) {
     throw new MailDeleteError("missing", "Draft no longer exists");
@@ -9802,9 +10077,9 @@ async function deleteLocalDraftVerified(mail, mailDir) {
   if (!/^[a-f0-9]{64}$/i.test(mail.revision)) {
     throw new MailDeleteError("invalid", "Invalid draft revision");
   }
-  const locksDir = resolve6(mailDirReal, ".locks");
+  const locksDir = resolve7(mailDirReal, ".locks");
   await ensureRealDirChain(mailDirReal, locksDir);
-  const lockPath = resolve6(locksDir, `${mail.id.trim()}.md.lock`);
+  const lockPath = resolve7(locksDir, `${mail.id.trim()}.md.lock`);
   try {
     return await withFlock(lockPath, deleteLockTimeoutMs, async () => {
       const content = await readFile5(target, "utf8").catch(() => null);
@@ -9814,9 +10089,9 @@ async function deleteLocalDraftVerified(mail, mailDir) {
       if (draftRevision2(content) !== mail.revision.toLowerCase()) {
         throw new MailDeleteError("changed", "Draft changed since it was loaded; refusing to delete newer work");
       }
-      const historyDir = resolve6(mailDirReal, "history", mail.id);
+      const historyDir = resolve7(mailDirReal, "history", mail.id);
       await ensureRealDirChain(mailDirReal, historyDir);
-      const historyPath = resolve6(historyDir, `${mail.revision}.md`);
+      const historyPath = resolve7(historyDir, `${mail.revision}.md`);
       const existingLstat = await lstat2(historyPath).catch(() => {
         return;
       });
@@ -9832,7 +10107,7 @@ async function deleteLocalDraftVerified(mail, mailDir) {
       } else if (existing) {
         throw new MailDeleteError("invalid", "History snapshot path is not a regular file");
       } else {
-        const tempPath = resolve6(historyDir, `${mail.revision}.md.tmp`);
+        const tempPath = resolve7(historyDir, `${mail.revision}.md.tmp`);
         for (let attempt = 0;; attempt += 1) {
           try {
             await writeFile(tempPath, content, { flag: "wx", mode: 384 });
@@ -9913,13 +10188,13 @@ async function removeDraftAttachmentVerified(mail, mailDir, attachment) {
   if (!validDraftId(mail.id)) {
     throw new MailAttachmentError("invalid", "Invalid mail id");
   }
-  const mailDirReal = await realpath3(resolve6(mailDir));
-  const target = resolve6(mail.filePath);
-  const targetDir = await realpath3(dirname5(target)).catch(() => null);
+  const mailDirReal = await realpath3(resolve7(mailDir));
+  const target = resolve7(mail.filePath);
+  const targetDir = await realpath3(dirname6(target)).catch(() => null);
   if (targetDir !== mailDirReal) {
     throw new MailAttachmentError("invalid", "Draft path is outside the mail folder");
   }
-  const expected = resolve6(mailDirReal, `${mail.id.trim()}.md`);
+  const expected = resolve7(mailDirReal, `${mail.id.trim()}.md`);
   const targetReal = await realpath3(target).catch(() => null);
   if (targetReal === null) {
     throw new MailAttachmentError("missing", "Draft no longer exists");
@@ -9930,9 +10205,9 @@ async function removeDraftAttachmentVerified(mail, mailDir, attachment) {
   if (!/^[a-f0-9]{64}$/i.test(mail.revision)) {
     throw new MailAttachmentError("invalid", "Invalid draft revision");
   }
-  const locksDir = resolve6(mailDirReal, ".locks");
+  const locksDir = resolve7(mailDirReal, ".locks");
   await ensureRealDirChain(mailDirReal, locksDir);
-  const lockPath = resolve6(locksDir, `${mail.id.trim()}.md.lock`);
+  const lockPath = resolve7(locksDir, `${mail.id.trim()}.md.lock`);
   try {
     return await withFlock(lockPath, deleteLockTimeoutMs, async () => {
       const revision = mail.revision.toLowerCase();
@@ -9969,7 +10244,7 @@ ${newFrontmatter}
 ${content.slice(end + `
 ---
 `.length)}`;
-      const tempPath = resolve6(mailDirReal, `${mail.id.trim()}.md.tmp`);
+      const tempPath = resolve7(mailDirReal, `${mail.id.trim()}.md.tmp`);
       for (let attempt = 0;; attempt += 1) {
         try {
           await writeFile(tempPath, newContent, { flag: "wx", mode: 384 });
@@ -10242,6 +10517,15 @@ async function handleMailApiRoutes(request, response, context) {
   return true;
 }
 // packages/api/src/server/plugins.ts
+function configuredFolderServerRegistry(registry, resolvedConfig) {
+  const disabled = new Set(resolvedConfig.plugins.disable);
+  const orderedIds = resolvedConfig.plugins.order.filter((id) => registry.has(id) && !disabled.has(id));
+  const ids = [
+    ...orderedIds,
+    ...[...registry.keys()].filter((id) => !disabled.has(id) && !orderedIds.includes(id))
+  ];
+  return new Map(ids.map((id) => [id, registry.get(id)]));
+}
 function createFolderServerPlugins(options = {}) {
   return [
     createCalendarPlugin(),
@@ -10249,14 +10533,63 @@ function createFolderServerPlugins(options = {}) {
     createAgentsPlugin({
       homeDir: options.agentsHomeDir
     }),
-    createTasksPlugin()
+    createNotesPlugin(),
+    createTasksPlugin(),
+    createProjectsPlugin()
   ];
 }
 function folderServerRegistry(options = {}) {
   return new Map(createFolderServerPlugins(options).map((plugin) => [plugin.id, plugin]));
 }
+function externalServerEntries() {
+  const source = process.env.KENNEL_EXTERNAL_SERVER_ENTRIES;
+  if (!source)
+    return [];
+  const value = JSON.parse(source);
+  if (!Array.isArray(value))
+    throw new Error("Invalid external plugin server config");
+  return value.map((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      throw new Error("Invalid external plugin server config");
+    const item = entry;
+    if (typeof item.id !== "string" || typeof item.module !== "string" || typeof item.symbol !== "string")
+      throw new Error("Invalid external plugin server config");
+    if (item.trigger !== undefined && typeof item.trigger !== "string")
+      throw new Error("Invalid external plugin server config");
+    return { id: item.id, module: item.module, symbol: item.symbol, trigger: item.trigger };
+  });
+}
+async function folderServerRegistryAsync(options = {}) {
+  const registry = folderServerRegistry(options);
+  for (const entry of externalServerEntries()) {
+    if (registry.has(entry.id))
+      throw new Error(`External plugin id collides with core plugin: ${entry.id}`);
+    const imported = await import(pathToFileURL(entry.module).href);
+    const value = imported[entry.symbol];
+    const plugin = typeof value === "function" ? value(options) : value;
+    if (!plugin || typeof plugin !== "object")
+      throw new Error(`External plugin ${entry.id} did not export ${entry.symbol}`);
+    const server = plugin;
+    if (server.id !== entry.id)
+      throw new Error(`External plugin id mismatch: expected ${entry.id}, got ${server.id}`);
+    if (registry.has(server.id))
+      throw new Error(`Duplicate external plugin id: ${server.id}`);
+    const withTrigger = entry.trigger ? {
+      ...server,
+      async detect(context) {
+        const detection = await server.detect(context);
+        if (detection.status === "unavailable" && existsSync2(resolve8(context.folder, entry.trigger))) {
+          return { status: "available" };
+        }
+        return detection;
+      }
+    } : server;
+    registry.set(server.id, withTrigger);
+  }
+  return registry;
+}
 async function scaffoldFolderPlugins(folder, options = {}) {
-  const root = resolve7(folder);
+  const root = resolve8(folder);
   const registry = folderServerRegistry(options);
   const created = [];
   const skipped = [];
@@ -10267,8 +10600,8 @@ async function scaffoldFolderPlugins(folder, options = {}) {
     const context = { folder: root };
     const result = await plugin.init(context);
     const files = result.files.filter((file) => {
-      const target = resolve7(root, file.path);
-      const contained = target === root || target.startsWith(root + sep6);
+      const target = resolve8(root, file.path);
+      const contained = target === root || target.startsWith(root + sep7);
       return contained && file.path !== ".";
     });
     supported.push({
@@ -10276,15 +10609,15 @@ async function scaffoldFolderPlugins(folder, options = {}) {
       files: files.map((file) => file.path)
     });
     for (const file of files) {
-      const target = resolve7(root, file.path);
-      const exists = await stat3(target).then(() => true).catch(() => false);
+      const target = resolve8(root, file.path);
+      const exists = await stat4(target).then(() => true).catch(() => false);
       if (exists && !options.force) {
         skipped.push({ path: file.path, plugin: plugin.id });
         continue;
       }
       if (options.write === false)
         continue;
-      await mkdir3(dirname6(target), { recursive: true });
+      await mkdir3(dirname7(target), { recursive: true });
       await writeFile2(target, file.content);
       created.push({ path: file.path, plugin: plugin.id });
     }
@@ -10294,7 +10627,9 @@ async function scaffoldFolderPlugins(folder, options = {}) {
 export {
   scaffoldFolderPlugins,
   handleMailApiRoutes,
+  folderServerRegistryAsync,
   folderServerRegistry,
   createFolderServerPlugins,
+  configuredFolderServerRegistry,
   FolderPluginFailure
 };