@michengai/dsh-skills-manager 1.2.19 → 1.2.21

package/lib/core.js

@@ -39,14 +39,27 @@ const EXTERNAL_SOURCE_ORDER = [
   "lingma",
   "antigravity"
 ];
+const CUSTOM_SOURCE_PREFIX = "custom:";
+const CUSTOM_SOURCE_ID_RE = /^custom:[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const MAX_CUSTOM_SOURCES = 32;
+const MAX_CUSTOM_LABEL_LENGTH = 48;
+const MAX_SOURCE_SCAN_DEPTH = 2;
+const MAX_SOURCE_SCAN_CANDIDATES = 40;
+function isCustomSourceKey(key) {
+  return typeof key === "string" && key.startsWith(CUSTOM_SOURCE_PREFIX);
+}
 function rankSources(sources, startRank) {
   const order = (root) => EXTERNAL_SOURCE_ORDER.indexOf(root.key);
   const external = sources.filter((root) => !root.native);
-  for (const root of external) {
+  const custom = external.filter((root) => isCustomSourceKey(root.key));
+  const preset = external.filter((root) => !isCustomSourceKey(root.key));
+  for (const root of preset) {
     if (order(root) < 0) throw new Error(`\u6280\u80FD\u6765\u6E90\u672A\u767B\u8BB0\u5230 EXTERNAL_SOURCE_ORDER: ${root.key}`);
   }
-  external.sort((a, b) => order(a) - order(b));
-  const ranks = new Map(external.map((root, index) => [root.key, startRank + index * 10]));
+  preset.sort((a, b) => order(a) - order(b));
+  const ranks = new Map(preset.map((root, index) => [root.key, startRank + index * 10]));
+  const customBase = startRank + preset.length * 10;
+  custom.forEach((root, index) => ranks.set(root.key, customBase + index * 10));
   return sources.map((root) => ({ ...root, rank: root.native ? root.rank : ranks.get(root.key) })).sort((a, b) => a.rank - b.rank);
 }
 const PROJECT_SOURCES = rankSources([
@@ -341,6 +354,18 @@ function userRoots() {
     root.defaultPath = root.path;
     root.path = override;
   }
+  for (const custom of loadRootPathConfig().customSources) {
+    roots.push({
+      key: custom.id,
+      path: custom.path,
+      label: custom.label,
+      ...custom.group ? { group: custom.group } : {},
+      mutable: false,
+      toggleable: true,
+      native: false,
+      custom: true
+    });
+  }
   return rankSources(roots, 500);
 }
 function projectIdentity(path) {
@@ -536,6 +561,7 @@ function rootPathError(code, message, params = {}) {
 function corruptRootPathConfig(file, reason) {
   return {
     paths: {},
+    customSources: [],
     warnings: [
       {
         code: "warning.rootPath.corrupt",
@@ -545,6 +571,49 @@ function corruptRootPathConfig(file, reason) {
     ]
   };
 }
+function customSourceSlug(label) {
+  const slug = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 24);
+  return slug || "source";
+}
+function normalizeCustomLabel(value) {
+  const label = typeof value === "string" ? value.trim() : "";
+  return label && label.length <= MAX_CUSTOM_LABEL_LENGTH ? label : "";
+}
+function parseCustomSources(value, warnings) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    warnings.push({
+      code: "warning.rootPath.invalid",
+      params: { path: "customSources" },
+      error: "\u81EA\u5B9A\u4E49\u6765\u6E90\u914D\u7F6E\u5FC5\u987B\u662F\u6570\u7EC4\uFF0C\u5DF2\u5FFD\u7565: customSources"
+    });
+    return [];
+  }
+  const accepted = [];
+  const ids = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  for (const entry of value.slice(0, MAX_CUSTOM_SOURCES)) {
+    const record = entry && typeof entry === "object" && !Array.isArray(entry) ? entry : null;
+    const id = record && typeof record.id === "string" ? record.id.trim() : "";
+    const label = record ? normalizeCustomLabel(record.label) : "";
+    const requested = record && typeof record.path === "string" ? record.path.trim() : "";
+    const group = record && typeof record.group === "string" ? normalizeCustomLabel(record.group) : "";
+    const identity = requested && isAbsolute(requested) ? pathIdentity(requested) : "";
+    if (!record || !CUSTOM_SOURCE_ID_RE.test(id) || !label || !requested || !isAbsolute(requested) || requested.length > MAX_ROOT_PATH_LENGTH || ids.has(id) || paths.has(identity)) {
+      const key = id || (record && typeof record.id === "string" ? record.id : "customSources");
+      warnings.push({
+        code: "warning.rootPath.invalid",
+        params: { path: key },
+        error: `\u81EA\u5B9A\u4E49\u6765\u6E90\u914D\u7F6E\u9879\u65E0\u6548\uFF0C\u5DF2\u5FFD\u7565: ${key}`
+      });
+      continue;
+    }
+    ids.add(id);
+    paths.add(identity);
+    accepted.push({ id, label, path: resolve(requested), ...group ? { group } : {} });
+  }
+  return accepted;
+}
 function readRootPathConfigFile() {
   const file = rootPathConfigPath();
   let raw;
@@ -552,7 +621,7 @@ function readRootPathConfigFile() {
     raw = readFileSync(file, "utf8");
   } catch (caught) {
     const error = caught;
-    if (error && error.code === "ENOENT") return { paths: {}, warnings: [] };
+    if (error && error.code === "ENOENT") return { paths: {}, customSources: [], warnings: [] };
     return corruptRootPathConfig(file, "\u6280\u80FD\u76EE\u5F55\u914D\u7F6E\u4E0D\u53EF\u8BFB");
   }
   let document;
@@ -578,7 +647,11 @@ function readRootPathConfigFile() {
     }
     accepted[key] = resolve(requested);
   }
-  return { paths: accepted, warnings };
+  const customSources = parseCustomSources(
+    document && typeof document === "object" && !Array.isArray(document) ? document.customSources : void 0,
+    warnings
+  );
+  return { paths: accepted, customSources, warnings };
 }
 function loadRootPathConfig() {
   if (!rootPathConfig) rootPathConfig = readRootPathConfigFile();
@@ -588,25 +661,97 @@ function reloadRootPathOverrides() {
   rootPathConfig = null;
   return loadRootPathConfig();
 }
-async function writeRootPathOverrides(config, key, value) {
-  const paths = { ...config.paths };
-  if (value === null) delete paths[key];
-  else paths[key] = value;
-  const nextPaths = Object.fromEntries(
-    Object.entries(paths).sort(([left], [right]) => left.localeCompare(right))
+async function writeRootPathConfig(config, next) {
+  const paths = Object.fromEntries(
+    Object.entries(next.paths ?? config.paths).sort(
+      ([left], [right]) => left.localeCompare(right)
+    )
   );
+  const customSources = next.customSources ?? config.customSources;
   await fs.mkdir(managerHomePath(), { recursive: true });
   await writeFileAtomically(
     rootPathConfigPath(),
-    `${JSON.stringify({ version: ROOTS_CONFIG_VERSION, paths: nextPaths }, null, 2)}
+    `${JSON.stringify({ version: ROOTS_CONFIG_VERSION, paths, customSources }, null, 2)}
 `
   );
-  config.paths = nextPaths;
+  config.paths = paths;
+  config.customSources = customSources;
   config.warnings = [];
 }
+async function writeRootPathOverrides(config, key, value) {
+  const paths = { ...config.paths };
+  if (value === null) delete paths[key];
+  else paths[key] = value;
+  await writeRootPathConfig(config, { paths });
+}
+async function validateSourceRootPath(requested, options = {}) {
+  if (!isAbsolute(requested))
+    return rootPathError(
+      "error.rootPath.absolute",
+      `\u6280\u80FD\u76EE\u5F55\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84: ${requested}`,
+      { path: requested }
+    );
+  if (requested.length > MAX_ROOT_PATH_LENGTH)
+    return rootPathError(
+      "error.rootPath.tooLong",
+      `\u6280\u80FD\u76EE\u5F55\u8DEF\u5F84\u8D85\u8FC7 ${MAX_ROOT_PATH_LENGTH} \u4E2A\u5B57\u7B26: ${requested}`,
+      { path: requested }
+    );
+  let info;
+  try {
+    info = await fs.stat(requested);
+  } catch {
+    return rootPathError(
+      "error.rootPath.notFound",
+      `\u6280\u80FD\u76EE\u5F55\u4E0D\u5B58\u5728: ${requested}`,
+      { path: requested }
+    );
+  }
+  if (!info.isDirectory())
+    return rootPathError(
+      "error.rootPath.notDirectory",
+      `\u6280\u80FD\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6\u5939: ${requested}`,
+      { path: requested }
+    );
+  const candidate = await comparisonPath(requested);
+  const managerHome = await comparisonPath(managerHomePath());
+  if (isSameOrDescendant(managerHome, candidate) || isSameOrDescendant(candidate, managerHome))
+    return rootPathError(
+      "error.rootPath.reserved",
+      `\u6280\u80FD\u76EE\u5F55\u4E0D\u80FD\u4E0E\u6280\u80FD\u7BA1\u7406\u5668\u7684\u72B6\u6001\u76EE\u5F55\u91CD\u53E0: ${requested}`,
+      { path: requested }
+    );
+  for (const other of userRoots()) {
+    if (other.key === options.excludeKey) continue;
+    const otherPath = await comparisonPath(other.path);
+    if (isSameOrDescendant(candidate, otherPath) || isSameOrDescendant(otherPath, candidate))
+      return rootPathError(
+        "error.rootPath.overlap",
+        `\u6280\u80FD\u76EE\u5F55\u4E0D\u80FD\u4E0E\u5176\u5B83\u6280\u80FD\u6765\u6E90\u91CD\u53E0: ${other.path}`,
+        { path: requested }
+      );
+  }
+  return { ok: true, path: resolve(requested) };
+}
 async function setRootPath(key, value) {
   const rootKey = typeof key === "string" ? key.trim() : "";
   const current = userRoots().find((root) => root.key === rootKey);
+  if (rootKey && isCustomSourceKey(rootKey)) {
+    if (!current)
+      return rootPathError(
+        "error.rootPath.unsupported",
+        `\u8BE5\u6280\u80FD\u6765\u6E90\u4E0D\u652F\u6301\u4FEE\u6539\u76EE\u5F55: ${rootKey}`,
+        { root: rootKey }
+      );
+    if (value === null || value === void 0 || typeof value === "string" && value.trim() === "") {
+      const removed = await removeCustomSource(rootKey);
+      if (removed.ok === false) return removed;
+      return { ok: true, root: { key: rootKey, path: current.path } };
+    }
+    const updated = await updateCustomSource(rootKey, { path: value });
+    if (updated.ok === false) return updated;
+    return { ok: true, root: { key: rootKey, path: updated.source.path } };
+  }
   if (!rootKey || !current || !OVERRIDABLE_ROOT_KEYS.has(rootKey))
     return rootPathError(
       "error.rootPath.unsupported",
@@ -626,10 +771,154 @@ async function setRootPath(key, value) {
       { path: String(value) }
     );
   const requested = value.trim();
-  if (!isAbsolute(requested))
+  if (pathIdentity(requested) === pathIdentity(defaultPath)) {
+    await writeRootPathOverrides(config, rootKey, null);
+    return { ok: true, root: { key: rootKey, path: defaultPath } };
+  }
+  const checked = await validateSourceRootPath(requested, { excludeKey: rootKey });
+  if (checked.ok === false) return checked;
+  await writeRootPathOverrides(config, rootKey, checked.path);
+  return { ok: true, root: { key: rootKey, path: checked.path, defaultPath } };
+}
+function nextCustomSourceId(label, taken) {
+  const base = CUSTOM_SOURCE_PREFIX + customSourceSlug(label);
+  if (!taken.has(base)) return base;
+  for (let index = 2; index <= MAX_CUSTOM_SOURCES + 1; index++) {
+    const candidate = `${base}-${index}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+  return "";
+}
+async function addCustomSources(input) {
+  const config = loadRootPathConfig();
+  const list = Array.isArray(input) ? input : [input];
+  if (!list.length)
+    return rootPathError("error.customSource.empty", "\u6CA1\u6709\u8981\u6DFB\u52A0\u7684\u6280\u80FD\u6765\u6E90", {});
+  const taken = new Set(userRoots().map((root) => root.key));
+  const next = [...config.customSources];
+  const added = [];
+  for (const entry of list) {
+    if (next.length >= MAX_CUSTOM_SOURCES)
+      return rootPathError(
+        "error.customSource.limit",
+        `\u81EA\u5B9A\u4E49\u6765\u6E90\u6570\u91CF\u5DF2\u8FBE\u4E0A\u9650 ${MAX_CUSTOM_SOURCES} \u4E2A`,
+        { limit: MAX_CUSTOM_SOURCES }
+      );
+    const record = entry && typeof entry === "object" ? entry : null;
+    const requested = record && typeof record.path === "string" ? record.path.trim() : "";
+    if (requested && isAbsolute(requested) && next.some((item) => pathIdentity(item.path) === pathIdentity(requested)))
+      continue;
+    const checked = await validateSourceRootPath(requested);
+    if (checked.ok === false) return checked;
+    const label = record && normalizeCustomLabel(record.label) || basename(checked.path);
+    if (!label)
+      return rootPathError(
+        "error.customSource.label",
+        `\u81EA\u5B9A\u4E49\u6765\u6E90\u5FC5\u987B\u6709\u663E\u793A\u540D: ${checked.path}`,
+        { path: checked.path }
+      );
+    if (next.some((item) => pathIdentity(item.path) === pathIdentity(checked.path)))
+      continue;
+    const id = nextCustomSourceId(label, taken);
+    if (!id)
+      return rootPathError(
+        "error.customSource.limit",
+        `\u81EA\u5B9A\u4E49\u6765\u6E90\u6570\u91CF\u5DF2\u8FBE\u4E0A\u9650 ${MAX_CUSTOM_SOURCES} \u4E2A`,
+        { limit: MAX_CUSTOM_SOURCES }
+      );
+    taken.add(id);
+    const group = record ? normalizeCustomLabel(record.group) : "";
+    const source = {
+      id,
+      label,
+      path: checked.path,
+      ...group ? { group } : {}
+    };
+    next.push(source);
+    added.push(source);
+  }
+  if (added.length) await writeRootPathConfig(config, { customSources: next });
+  return { ok: true, added };
+}
+async function updateCustomSource(key, patch) {
+  const id = typeof key === "string" ? key.trim() : "";
+  const config = loadRootPathConfig();
+  const index = config.customSources.findIndex((item) => item.id === id);
+  if (!CUSTOM_SOURCE_ID_RE.test(id) || index < 0)
+    return rootPathError(
+      "error.customSource.unknown",
+      `\u672A\u767B\u8BB0\u7684\u81EA\u5B9A\u4E49\u6765\u6E90: ${id || "(\u7A7A)"}`,
+      { root: id }
+    );
+  const record = patch && typeof patch === "object" ? patch : {};
+  const current = config.customSources[index];
+  const label = record.label === void 0 ? current.label : normalizeCustomLabel(record.label);
+  if (!label)
+    return rootPathError(
+      "error.customSource.label",
+      `\u81EA\u5B9A\u4E49\u6765\u6E90\u5FC5\u987B\u6709\u663E\u793A\u540D: ${String(record.label)}`,
+      { path: String(record.label) }
+    );
+  let path = current.path;
+  if (record.path !== void 0) {
+    const requested = typeof record.path === "string" ? record.path.trim() : "";
+    const checked = await validateSourceRootPath(requested, { excludeKey: id });
+    if (checked.ok === false) return checked;
+    path = checked.path;
+  }
+  const group = record.group === void 0 ? current.group : normalizeCustomLabel(record.group) || void 0;
+  const source = { id, label, path, ...group ? { group } : {} };
+  const next = config.customSources.map(
+    (item, position) => position === index ? source : item
+  );
+  await writeRootPathConfig(config, { customSources: next });
+  return { ok: true, source };
+}
+async function removeCustomSource(key) {
+  const id = typeof key === "string" ? key.trim() : "";
+  const config = loadRootPathConfig();
+  if (!config.customSources.some((item) => item.id === id))
+    return rootPathError(
+      "error.customSource.unknown",
+      `\u672A\u767B\u8BB0\u7684\u81EA\u5B9A\u4E49\u6765\u6E90: ${id || "(\u7A7A)"}`,
+      { root: id }
+    );
+  await writeRootPathConfig(config, {
+    customSources: config.customSources.filter((item) => item.id !== id)
+  });
+  return { ok: true, removed: id };
+}
+async function collectSkillDirectories(root) {
+  const found = [];
+  async function walk(directory, depth, segments) {
+    if (found.length >= MAX_SOURCE_SCAN_CANDIDATES) return;
+    const skillsDir = join(directory, "skills");
+    if ((await lstatOrNull(skillsDir))?.isDirectory())
+      found.push({ path: skillsDir, depth, segments });
+    if (depth >= MAX_SOURCE_SCAN_DEPTH) return;
+    let entries;
+    try {
+      entries = await fs.readdir(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (found.length >= MAX_SOURCE_SCAN_CANDIDATES) return;
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".") || entry.name === "skills" || entry.name === "node_modules")
+        continue;
+      await walk(join(directory, entry.name), depth + 1, segments.concat(entry.name));
+    }
+  }
+  await walk(root, 0, []);
+  return found;
+}
+async function scanCustomSourceCandidates(inputPath) {
+  const requested = typeof inputPath === "string" ? inputPath.trim() : "";
+  if (!requested || !isAbsolute(requested))
     return rootPathError(
       "error.rootPath.absolute",
-      `\u6280\u80FD\u76EE\u5F55\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84: ${requested}`,
+      `\u6280\u80FD\u76EE\u5F55\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84: ${requested || "(\u7A7A)"}`,
       { path: requested }
     );
   if (requested.length > MAX_ROOT_PATH_LENGTH)
@@ -638,10 +927,6 @@ async function setRootPath(key, value) {
       `\u6280\u80FD\u76EE\u5F55\u8DEF\u5F84\u8D85\u8FC7 ${MAX_ROOT_PATH_LENGTH} \u4E2A\u5B57\u7B26: ${requested}`,
       { path: requested }
     );
-  if (pathIdentity(requested) === pathIdentity(defaultPath)) {
-    await writeRootPathOverrides(config, rootKey, null);
-    return { ok: true, root: { key: rootKey, path: defaultPath } };
-  }
   let info;
   try {
     info = await fs.stat(requested);
@@ -658,26 +943,24 @@ async function setRootPath(key, value) {
       `\u6280\u80FD\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6\u5939: ${requested}`,
       { path: requested }
     );
-  const candidate = await comparisonPath(requested);
-  const managerHome = await comparisonPath(managerHomePath());
-  if (isSameOrDescendant(managerHome, candidate) || isSameOrDescendant(candidate, managerHome))
-    return rootPathError(
-      "error.rootPath.reserved",
-      `\u6280\u80FD\u76EE\u5F55\u4E0D\u80FD\u4E0E\u6280\u80FD\u7BA1\u7406\u5668\u7684\u72B6\u6001\u76EE\u5F55\u91CD\u53E0: ${requested}`,
-      { path: requested }
-    );
-  for (const other of userRoots()) {
-    if (other.key === rootKey) continue;
-    const otherPath = await comparisonPath(other.path);
-    if (isSameOrDescendant(candidate, otherPath) || isSameOrDescendant(otherPath, candidate))
-      return rootPathError(
-        "error.rootPath.overlap",
-        `\u6280\u80FD\u76EE\u5F55\u4E0D\u80FD\u4E0E\u5176\u5B83\u6280\u80FD\u6765\u6E90\u91CD\u53E0: ${other.path}`,
-        { path: requested }
-      );
+  const root = resolve(requested);
+  const product = basename(root) || root;
+  const registered = new Set(userRoots().map((item) => pathIdentity(item.path)));
+  const candidates = [];
+  for (const item of await collectSkillDirectories(root)) {
+    const skills = await discoverReadonlyEntries(item.path);
+    candidates.push({
+      path: item.path,
+      label: item.depth === 0 ? product : [product].concat(item.segments).join(" / "),
+      group: product,
+      depth: item.depth,
+      skillCount: skills.entries.length,
+      // 与已有来源重叠的候选仍然列出来，但界面要禁止登记，否则会绕过停用策略。
+      conflict: await overlapsUserSkillRoot(item.path),
+      registered: registered.has(pathIdentity(item.path))
+    });
   }
-  await writeRootPathOverrides(config, rootKey, resolve(requested));
-  return { ok: true, root: { key: rootKey, path: resolve(requested), defaultPath } };
+  return { ok: true, root, candidates };
 }
 async function browseDirectories(inputPath) {
   const requested = String(inputPath == null ? "" : inputPath).trim();
@@ -2456,17 +2739,17 @@ async function replaceWithCopy(source, dest, isDir, existing = []) {
   try {
     for (const path of existing) {
       const backup = temporaryPath(path, "backup");
-      await fs.rename(path, backup);
+      await renameWithRetry(path, backup);
       backups.push({ path, backup });
     }
-    await fs.rename(stage, dest);
+    await renameWithRetry(stage, dest);
   } catch (caught) {
     const error = caught;
     await fs.rm(stage, { recursive: true, force: true }).catch(() => void 0);
     const rollbackFailures = [];
     for (const item of backups.reverse()) {
       try {
-        await fs.rename(item.backup, item.path);
+        await renameWithRetry(item.backup, item.path);
       } catch (caught2) {
         const rollbackError = caught2;
         rollbackFailures.push(item.backup);
@@ -2848,7 +3131,7 @@ async function prepareUploadedSource(sessionRoot, input) {
   const batchRoot = join(sessionRoot, "batch");
   const wrappedRoot = join(batchRoot, skillName);
   await fs.mkdir(batchRoot, { recursive: true });
-  await fs.rename(contentRoot, wrappedRoot);
+  await renameWithRetry(contentRoot, wrappedRoot);
   return batchRoot;
 }
 async function importUploadedSkill(input, log, options = {}) {
@@ -2919,7 +3202,7 @@ description: ${yamlString(description)}
 ${body}
 `;
     await fs.writeFile(join(stage, "SKILL.md"), content, "utf8");
-    await fs.rename(stage, target);
+    await renameWithRetry(stage, target);
   } catch (caught) {
     const error = caught;
     await fs.rm(stage, { recursive: true, force: true }).catch(() => void 0);
@@ -3211,7 +3494,7 @@ async function state(options = {}) {
         params: { path: root.path },
         error: `\u6280\u80FD\u626B\u63CF\u8FBE\u5230\u904D\u5386\u4E0A\u9650\uFF0C\u90E8\u5206\u6280\u80FD\u672A\u663E\u793A: ${root.path}`
       });
-    if (root.defaultPath && !exists)
+    if ((root.defaultPath || root.custom) && !exists)
       result.warnings.push({
         code: "warning.rootPath.missing",
         params: { path: root.path },
@@ -3261,6 +3544,8 @@ async function state(options = {}) {
       native: root.native,
       rank: root.rank,
       scope: root.scope || "user",
+      ...root.custom ? { custom: true } : {},
+      ...root.group ? { group: root.group } : {},
       ...root.projectRoot ? {
         projectRoot: root.projectRoot,
         projectName: root.projectName,
@@ -3310,7 +3595,9 @@ async function state(options = {}) {
   return result;
 }
 export {
+  CUSTOM_SOURCE_PREFIX,
   KEBAB_RE,
+  addCustomSources,
   assignSkillCategory,
   browseDirectories,
   checkedRepositoryRootDefinition,
@@ -3326,6 +3613,7 @@ export {
   importSkill,
   importUploadedSkill,
   indexRegisteredWorkspaces,
+  isCustomSourceKey,
   listProviderCandidates,
   listTrash,
   listWorkspaces,
@@ -3340,6 +3628,7 @@ export {
   projectRoots,
   readManagerState,
   reloadRootPathOverrides,
+  removeCustomSource,
   renameCategory,
   renameWithRetry,
   repositoryDestinations,
@@ -3349,6 +3638,7 @@ export {
   resolveWorkspaceTarget,
   restoreTrash,
   rootPathConfigPath,
+  scanCustomSourceCandidates,
   scanEntries,
   setCategoryEnabled,
   setOnlineUpdate,
@@ -3361,6 +3651,7 @@ export {
   toKebab,
   trashRootPath,
   unquote,
+  updateCustomSource,
   userRoots,
   workspaceSkills
 };