@fieldwangai/agentflow 0.1.71 → 0.1.72

package/bin/lib/admin-storage-config.mjs

@@ -7,7 +7,10 @@ import {
   expandAgentflowHomePath,
   getAgentflowDataRoot,
   getAgentflowDataRootOverride,
+  getAgentflowSkillsRoot,
+  getAgentflowSkillsRootOverride,
   writeAgentflowDataRootOverride,
+  writeAgentflowSkillsRootOverride,
 } from "./paths.mjs";
 
 function defaultAgentflowDataRoot() {
@@ -28,6 +31,14 @@ function normalizeDataRoot(raw) {
   return dataRoot;
 }
 
+function normalizeSkillsRoot(raw) {
+  const skillsRoot = expandAgentflowHomePath(raw);
+  if (skillsRoot && !path.isAbsolute(skillsRoot)) {
+    throw new Error("skillsRoot must be an absolute path");
+  }
+  return skillsRoot;
+}
+
 function copyEntry(src, dest) {
   const stat = fs.lstatSync(src);
   if (stat.isSymbolicLink()) {
@@ -45,6 +56,12 @@ function copyEntry(src, dest) {
   fs.copyFileSync(src, dest);
 }
 
+function copyEntryIfMissing(src, dest) {
+  if (fs.existsSync(dest)) return false;
+  copyEntry(src, dest);
+  return true;
+}
+
 function migrateDataRoot(oldRoot, newRoot) {
   const from = path.resolve(oldRoot);
   const to = path.resolve(newRoot);
@@ -63,9 +80,49 @@ function migrateDataRoot(oldRoot, newRoot) {
   return { migrated: true, copied: true };
 }
 
+function legacyCodexSkillsRoot() {
+  return path.join(os.homedir(), ".codex", "skills");
+}
+
+function migrateSkillsRoot(oldRoot, newRoot) {
+  const from = path.resolve(oldRoot);
+  const to = path.resolve(newRoot);
+  if (from === to) return { migrated: false, copied: false };
+  if (pathInside(from, to)) {
+    throw new Error("skillsRoot target cannot be inside the current skills root");
+  }
+  if (pathInside(to, from)) {
+    throw new Error("skillsRoot target cannot be a parent of the current skills root");
+  }
+  fs.mkdirSync(to, { recursive: true });
+  if (!fs.existsSync(from)) return { migrated: true, copied: false };
+  for (const name of fs.readdirSync(from)) {
+    copyEntry(path.join(from, name), path.join(to, name));
+  }
+  return { migrated: true, copied: true };
+}
+
+function migrateLegacyCodexSkills(targetRoot) {
+  const from = legacyCodexSkillsRoot();
+  const to = path.resolve(targetRoot);
+  const source = path.resolve(from);
+  if (source === to || !fs.existsSync(source)) return { migrated: false, copied: 0, source };
+  if (pathInside(source, to) || pathInside(to, source)) return { migrated: false, copied: 0, source };
+  fs.mkdirSync(to, { recursive: true });
+  let copied = 0;
+  for (const name of fs.readdirSync(source)) {
+    if (copyEntryIfMissing(path.join(source, name), path.join(to, name))) copied += 1;
+  }
+  return { migrated: copied > 0, copied, source };
+}
+
 export function readAdminStorageConfig() {
   const envDataRoot = normalizeDataRoot(process.env.AGENTFLOW_HOME || "");
+  const envSkillsRoot = normalizeSkillsRoot(process.env.AGENTFLOW_SKILLS_ROOT || "");
   const configuredDataRoot = getAgentflowDataRootOverride();
+  const configuredSkillsRoot = getAgentflowSkillsRootOverride();
+  const skillsRoot = getAgentflowSkillsRoot();
+  const legacySkillsRoot = legacyCodexSkillsRoot();
   return {
     version: 1,
     dataRoot: getAgentflowDataRoot(),
@@ -73,21 +130,49 @@ export function readAdminStorageConfig() {
     defaultDataRoot: defaultAgentflowDataRoot(),
     envDataRoot,
     envLocked: Boolean(envDataRoot),
+    skillsRoot,
+    configuredSkillsRoot,
+    defaultSkillsRoot: path.join(getAgentflowDataRoot(), "skills"),
+    envSkillsRoot,
+    skillsEnvLocked: Boolean(envSkillsRoot),
+    legacySkillsRoot,
+    legacySkillsRootExists: fs.existsSync(legacySkillsRoot),
     configPath: AGENTFLOW_HOME_CONFIG_PATH,
   };
 }
 
 export function writeAdminStorageConfig(config = {}) {
   const current = readAdminStorageConfig();
-  if (current.envLocked) {
-    throw new Error("AGENTFLOW_HOME is set; update the environment variable instead of Admin Settings");
-  }
   const nextRoot = normalizeDataRoot(config.dataRoot ?? "");
   if (!nextRoot) throw new Error("dataRoot is required");
-  const migration = migrateDataRoot(current.dataRoot, nextRoot);
-  writeAgentflowDataRootOverride(nextRoot);
+  let migration = { migrated: false, copied: false };
+  if (current.envLocked) {
+    if (path.resolve(nextRoot) !== path.resolve(current.dataRoot)) {
+      throw new Error("AGENTFLOW_HOME is set; update the environment variable instead of Admin Settings");
+    }
+  } else {
+    migration = migrateDataRoot(current.dataRoot, nextRoot);
+    writeAgentflowDataRootOverride(nextRoot);
+  }
+  const afterDataRoot = readAdminStorageConfig();
+  if (afterDataRoot.skillsEnvLocked) {
+    return {
+      ...afterDataRoot,
+      migration,
+      skillsMigration: { skipped: true, reason: "AGENTFLOW_SKILLS_ROOT is set" },
+    };
+  }
+  const nextSkillsRoot = normalizeSkillsRoot(config.skillsRoot ?? afterDataRoot.defaultSkillsRoot);
+  if (!nextSkillsRoot) throw new Error("skillsRoot is required");
+  const skillsMigration = migrateSkillsRoot(current.skillsRoot, nextSkillsRoot);
+  writeAgentflowSkillsRootOverride(nextSkillsRoot);
+  const legacySkillsMigration = config.migrateLegacySkills === false
+    ? { migrated: false, copied: 0, source: legacyCodexSkillsRoot(), skipped: true }
+    : migrateLegacyCodexSkills(nextSkillsRoot);
   return {
     ...readAdminStorageConfig(),
     migration,
+    skillsMigration,
+    legacySkillsMigration,
   };
 }

package/bin/lib/composer-skill-router.mjs

@@ -137,18 +137,26 @@ export function readComposerSkillDetail(packageRoot, workspaceRoot, keyOrName) {
   return registryReadSkillDetail(packageRoot, workspaceRoot, keyOrName);
 }
 
+function skillNameFromKey(keyOrName) {
+  const value = String(keyOrName || "").trim();
+  if (!value) return "";
+  const idx = value.indexOf(":");
+  return idx >= 0 ? value.slice(idx + 1).trim() : value;
+}
+
 export function loadResourcesForSkillKeys(skillKeys, packageRoot, workspaceRoot) {
   if (!Array.isArray(skillKeys) || skillKeys.length === 0) {
     return { skills: [], references: [], skillsHint: "", hasContext: false };
   }
   const wanted = new Set(skillKeys.map((x) => String(x || "").trim()).filter(Boolean));
   if (wanted.size === 0) return { skills: [], references: [], skillsHint: "", hasContext: false };
+  const wantedNames = new Set(Array.from(wanted).map(skillNameFromKey).filter(Boolean));
 
   const exactByKey = new Map(registryListSkills(packageRoot, workspaceRoot).map((item) => [item.key, item]));
   const candidateItems = [];
   const seenKeys = new Set();
   for (const item of registryListUniqueSkills(packageRoot, workspaceRoot)) {
-    if (!wanted.has(item.key) && !wanted.has(item.name)) continue;
+    if (!wanted.has(item.key) && !wanted.has(item.name) && !wantedNames.has(item.name)) continue;
     candidateItems.push(item);
     seenKeys.add(item.key);
   }

package/bin/lib/paths.mjs

@@ -49,6 +49,11 @@ export function getAgentflowDataRootOverride() {
   return expandAgentflowHomePath(config.dataRoot || "");
 }
 
+export function getAgentflowSkillsRootOverride() {
+  const config = readAgentflowHomeConfig();
+  return expandAgentflowHomePath(config.skillsRoot || "");
+}
+
 export function writeAgentflowDataRootOverride(dataRoot) {
   const nextRoot = expandAgentflowHomePath(dataRoot);
   if (nextRoot && !path.isAbsolute(nextRoot)) {
@@ -62,6 +67,19 @@ export function writeAgentflowDataRootOverride(dataRoot) {
   return nextRoot;
 }
 
+export function writeAgentflowSkillsRootOverride(skillsRoot) {
+  const nextRoot = expandAgentflowHomePath(skillsRoot);
+  if (nextRoot && !path.isAbsolute(nextRoot)) {
+    throw new Error("skillsRoot must be an absolute path");
+  }
+  const current = readAgentflowHomeConfig();
+  const next = { ...current, skillsRoot: nextRoot };
+  if (!nextRoot) delete next.skillsRoot;
+  fs.mkdirSync(path.dirname(AGENTFLOW_HOME_CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(AGENTFLOW_HOME_CONFIG_PATH, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  return nextRoot;
+}
+
 export function getAgentflowDataRoot() {
   const env = process.env.AGENTFLOW_HOME;
   if (env != null && String(env).trim() !== "") {
@@ -72,6 +90,16 @@ export function getAgentflowDataRoot() {
   return path.join(os.homedir(), "agentflow");
 }
 
+export function getAgentflowSkillsRoot() {
+  const env = process.env.AGENTFLOW_SKILLS_ROOT;
+  if (env != null && String(env).trim() !== "") {
+    return expandAgentflowHomePath(env);
+  }
+  const configured = getAgentflowSkillsRootOverride();
+  if (configured) return configured;
+  return path.join(getAgentflowDataRoot(), "skills");
+}
+
 export const AGENTFLOW_DEFAULT_USER_ID = "";
 
 export function sanitizeAgentflowUserId(userId) {

package/bin/lib/skill-registry.mjs

@@ -2,6 +2,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import yaml from "js-yaml";
+import { getAgentflowSkillsRoot } from "./paths.mjs";
 
 const fileCache = new Map();
 const CACHE_TTL_MS = 60_000;
@@ -9,10 +10,11 @@ const SOURCE_PRIORITY = new Map([
   ["workspace-agents", 100],
   ["workspace-codex", 95],
   ["workspace-cursor", 90],
+  ["agentflow-root", 85],
   ["builtin", 80],
-  ["global-agents", 70],
-  ["global-codex", 65],
-  ["global-cursor", 60],
+  ["global-agents", 55],
+  ["global-codex", 50],
+  ["global-cursor", 45],
 ]);
 
 function readFileCached(absPath) {
@@ -28,6 +30,10 @@ function readFileCached(absPath) {
   }
 }
 
+export function clearSkillRegistryCache() {
+  fileCache.clear();
+}
+
 export function stripSkillFrontmatter(content) {
   const raw = String(content || "");
   const match = raw.match(/^---\s*\r?\n[\s\S]*?\r?\n---\s*\r?\n?/);
@@ -109,11 +115,17 @@ export function defaultSkillSources(packageRoot, workspaceRoot) {
     },
   ];
   if (workspaceRoot) sources.push(...workspaceSkillSources(workspaceRoot, "workspace", "工作区"));
+  sources.push({
+    source: "agentflow-root",
+    sourceLabel: "AgentFlow Skills",
+    dir: getAgentflowSkillsRoot(),
+    installedBy: "agentflow-admin",
+  });
   const home = os.homedir();
   sources.push(
-    { source: "global-agents", sourceLabel: "全局 .agents", dir: path.join(home, ".agents", "skills"), installedBy: "global" },
-    { source: "global-cursor", sourceLabel: "全局 .cursor", dir: path.join(home, ".cursor", "skills"), installedBy: "global" },
-    { source: "global-codex", sourceLabel: "全局 .codex", dir: path.join(home, ".codex", "skills"), installedBy: "skillhub" },
+    { source: "global-agents", sourceLabel: "Legacy ~/.agents", dir: path.join(home, ".agents", "skills"), installedBy: "global" },
+    { source: "global-cursor", sourceLabel: "Legacy ~/.cursor", dir: path.join(home, ".cursor", "skills"), installedBy: "global" },
+    { source: "global-codex", sourceLabel: "Legacy ~/.codex", dir: path.join(home, ".codex", "skills"), installedBy: "skillhub-legacy" },
   );
   return sources;
 }
@@ -183,9 +195,10 @@ export function listUniqueSkills(packageRoot, workspaceRoot, opts = {}) {
 export function readSkillDetail(packageRoot, workspaceRoot, keyOrName) {
   const wanted = String(keyOrName || "").trim();
   if (!wanted) return null;
+  const wantedName = wanted.includes(":") ? wanted.slice(wanted.indexOf(":") + 1).trim() : wanted;
   const all = listSkills(packageRoot, workspaceRoot);
   const item = all.find((skill) => skill.key === wanted)
-    || dedupeSkillsByName(all).find((skill) => skill.name === wanted);
+    || dedupeSkillsByName(all).find((skill) => skill.name === wanted || skill.name === wantedName);
   if (!item) return null;
   return item;
 }

package/bin/lib/ui-server.mjs

@@ -45,6 +45,7 @@ import {
   PACKAGE_ROOT,
   ARCHIVED_PIPELINES_DIR_NAME,
   getAgentflowDataRoot,
+  getAgentflowSkillsRoot,
   getAgentflowUserConfigAbs,
   getAgentflowUserDataRoot,
   getUserPipelinesRoot,
@@ -62,6 +63,7 @@ import {
   buildSkillInjectionBlock,
   buildSkillCompactInjectionBlock,
 } from "./composer-skill-router.mjs";
+import { clearSkillRegistryCache } from "./skill-registry.mjs";
 import { COMPOSER_NODE_SPEC_FILENAME } from "./composer-planner.mjs";
 import { listRecentRunsFromDisk } from "./recent-runs.mjs";
 import {
@@ -1134,6 +1136,22 @@ function normalizeSkillhubListPayload(raw) {
   }).filter((x) => x.name);
 }
 
+function skillhubManagedSkillsDir() {
+  const dir = getAgentflowSkillsRoot();
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function skillhubListArgs(target, agent) {
+  const normalizedTarget = String(target || "agentflow").trim();
+  const normalizedAgent = String(agent || "codex").trim();
+  const args = ["list", "--json"];
+  if (normalizedTarget === "all") args.push("--all");
+  else if (normalizedTarget === "legacy-global") args.push("--global", "--agent", normalizedAgent);
+  else args.push("--dir", skillhubManagedSkillsDir());
+  return args;
+}
+
 function skillhubInstallArgs(payload, { uninstall = false } = {}) {
   const slug = String(payload?.slug || payload?.name || "").trim();
   if (!slug && !payload?.collection) return null;
@@ -1144,10 +1162,12 @@ function skillhubInstallArgs(payload, { uninstall = false } = {}) {
     args.push(slug);
   }
   if (payload?.skillId) args.push("--skill-id", String(payload.skillId).trim());
-  const target = String(payload?.target || "project").trim();
+  const target = String(payload?.target || "agentflow").trim();
   const agent = String(payload?.agent || "codex").trim();
-  if (target === "global") {
+  if (target === "global" || target === "legacy-global") {
     args.push("--global", "--agent", agent);
+  } else if (target === "agentflow") {
+    args.push("--dir", skillhubManagedSkillsDir());
   } else if (payload?.dir) {
     args.push("--dir", String(payload.dir).trim());
   }
@@ -5620,6 +5640,7 @@ export function startUiServer({
         }
         try {
           const config = writeAdminStorageConfig(payload?.config || payload || {});
+          clearSkillRegistryCache();
           json(res, 200, { ok: true, config });
         } catch (e) {
           json(res, 400, { error: (e && e.message) || String(e) });
@@ -7058,17 +7079,19 @@ export function startUiServer({
     }
 
     if (req.method === "GET" && url.pathname === "/api/skillhub/list") {
-      const target = url.searchParams.get("target") || "global";
+      const target = url.searchParams.get("target") || "agentflow";
       const agent = url.searchParams.get("agent") || "codex";
-      const args = ["list", "--json"];
-      if (target === "all") args.push("--all");
-      else if (target === "global") args.push("--global", "--agent", agent);
+      const args = skillhubListArgs(target, agent);
       const result = await runSkillhub(args, { cwd: root });
       if (!result.ok) {
         json(res, 500, { error: result.error, stdout: result.stdout });
         return;
       }
-      json(res, 200, { skills: normalizeSkillhubListPayload(parseJsonText(result.stdout, [])) });
+      json(res, 200, {
+        skills: normalizeSkillhubListPayload(parseJsonText(result.stdout, [])),
+        target,
+        skillsRoot: target === "agentflow" ? getAgentflowSkillsRoot() : "",
+      });
       return;
     }
 
@@ -7113,6 +7136,10 @@ export function startUiServer({
     }
 
     if (req.method === "POST" && url.pathname === "/api/skillhub/install") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin required" });
+        return;
+      }
       let payload;
       try {
         payload = JSON.parse(await readBody(req));
@@ -7125,16 +7152,13 @@ export function startUiServer({
         json(res, 400, { error: "Missing skill slug or collection" });
         return;
       }
-      if (payload?.collection && !authUser?.isAdmin) {
-        json(res, 403, { error: "Admin required" });
-        return;
-      }
       const beforeSkills = payload?.collection ? listComposerSkills(PACKAGE_ROOT, root) : [];
       const result = await runSkillhub(args, { cwd: root, timeoutMs: 180_000, maxBuffer: 4 * 1024 * 1024 });
       if (!result.ok) {
         json(res, 500, { error: result.error, stdout: result.stdout });
         return;
       }
+      clearSkillRegistryCache();
       let skillCollections = null;
       if (payload?.collection) {
         const afterSkills = listComposerSkills(PACKAGE_ROOT, root);
@@ -7146,6 +7170,10 @@ export function startUiServer({
     }
 
     if (req.method === "POST" && url.pathname === "/api/skillhub/uninstall") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin required" });
+        return;
+      }
       let payload;
       try {
         payload = JSON.parse(await readBody(req));
@@ -7158,21 +7186,22 @@ export function startUiServer({
         json(res, 400, { error: "Missing skill slug or collection" });
         return;
       }
-      if (payload?.collection && !authUser?.isAdmin) {
-        json(res, 403, { error: "Admin required" });
-        return;
-      }
       const result = await runSkillhub(args, { cwd: root, timeoutMs: 120_000, maxBuffer: 4 * 1024 * 1024 });
       if (!result.ok) {
         json(res, 500, { error: result.error, stdout: result.stdout });
         return;
       }
+      clearSkillRegistryCache();
       const skillCollections = payload?.collection ? removeSkillhubCollectionGroup(userCtx, payload.collection, root) : null;
       json(res, 200, { ok: true, stdout: result.stdout, skillCollections });
       return;
     }
 
     if (req.method === "POST" && url.pathname === "/api/skillhub/update") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin required" });
+        return;
+      }
       const result = await runSkillhub(["update"], { cwd: root, timeoutMs: 180_000, maxBuffer: 4 * 1024 * 1024 });
       if (!result.ok) {
         json(res, 500, { error: result.error, stdout: result.stdout });