@laitszkin/apollo-toolkit 3.2.2 → 3.3.1

package/lib/installer.js

@@ -13,6 +13,7 @@ const TARGET_DEFINITIONS = Object.freeze([
 const VALID_MODES = TARGET_DEFINITIONS.map(({ id }) => id);
 const COPY_FILES = new Set(['AGENTS.md', 'CHANGELOG.md', 'LICENSE', 'README.md', 'package.json']);
 const COPY_DIRS = new Set(['scripts']);
+const MANIFEST_FILENAME = '.apollo-toolkit-manifest.json';
 
 function resolveHomeDirectory(env = process.env) {
   return env.HOME || env.USERPROFILE || os.homedir();
@@ -82,7 +83,6 @@ async function listSkillNames(rootDir, modes = []) {
     }
   }
 
-  // For codex mode, also include codex-specific skills
   if (modes.includes('codex')) {
     const codexDir = path.join(rootDir, 'codex');
     if (fs.existsSync(codexDir)) {
@@ -111,8 +111,81 @@ async function listCodexSkillNames(rootDir) {
     .sort();
 }
 
-function getTargetSkillNames({ targetMode, sharedSkillNames, codexSkillNames }) {
-  if (targetMode !== 'codex') {
+// Read manifest from a target directory, returning { skills, historicalSkills, linkMode } or null.
+async function readManifest(targetRoot) {
+  const manifestPath = path.join(targetRoot, MANIFEST_FILENAME);
+  try {
+    const raw = await fsp.readFile(manifestPath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function isSafeSkillName(skillName) {
+  return typeof skillName === 'string'
+    && skillName.length > 0
+    && !skillName.includes('\0')
+    && !skillName.includes('/')
+    && !skillName.includes('\\')
+    && !path.isAbsolute(skillName)
+    && !path.win32.isAbsolute(skillName)
+    && skillName !== '.'
+    && skillName !== '..';
+}
+
+function getManifestSkillNames(manifest) {
+  return [...new Set([
+    ...(Array.isArray(manifest.historicalSkills) ? manifest.historicalSkills : []),
+    ...(Array.isArray(manifest.skills) ? manifest.skills : []),
+  ])].filter(isSafeSkillName).sort();
+}
+
+// Write manifest to a target directory.
+async function writeManifest(targetRoot, { version, linkMode, skills, previousSkills = [] }) {
+  const historicalSkills = [...new Set([...previousSkills, ...skills])].sort();
+  const manifest = {
+    version,
+    installedAt: new Date().toISOString(),
+    linkMode,
+    skills: [...skills].sort(),
+    historicalSkills,
+  };
+  await fsp.mkdir(targetRoot, { recursive: true });
+  await fsp.writeFile(
+    path.join(targetRoot, MANIFEST_FILENAME),
+    `${JSON.stringify(manifest, null, 2)}\n`,
+    'utf8',
+  );
+}
+
+// Read all current + historically appeared skill names with deduplication.
+async function listAllKnownSkillNames({ toolkitHome, modes = [], env = process.env }) {
+  const allNames = new Set();
+
+  // Current skills from toolkit home
+  const currentSkills = await listSkillNames(toolkitHome, modes).catch(() => []);
+  for (const name of currentSkills) {
+    allNames.add(name);
+  }
+
+  // Historical skills from all target manifests
+  const targets = await getUninstallTargetRoots(modes, env);
+  for (const target of targets) {
+    const manifest = await readManifest(target.root);
+    if (manifest && manifest.historicalSkills) {
+      for (const name of getManifestSkillNames(manifest)) {
+        allNames.add(name);
+      }
+    }
+  }
+
+  return [...allNames].sort();
+}
+
+function getTargetSkillNames({ targetMode, sharedSkillNames, codexSkillNames, includeExclusiveSkills = false }) {
+  const includeCodexSkills = targetMode === 'codex' || includeExclusiveSkills;
+  if (!includeCodexSkills || codexSkillNames.length === 0) {
     return sharedSkillNames;
   }
 
@@ -289,6 +362,21 @@ async function getTargetRoots(modes, env = process.env) {
   return targets;
 }
 
+async function getUninstallTargetRoots(modes = VALID_MODES, env = process.env) {
+  const targets = [];
+
+  for (const mode of normalizeModes(modes)) {
+    try {
+      targets.push(...await getTargetRoots([mode], env));
+    } catch {
+      // Uninstall is best-effort across agents. A missing OpenClaw workspace
+      // must not prevent cleanup from Codex, Trae, Agents, or Claude Code.
+    }
+  }
+
+  return targets;
+}
+
 async function ensureDirectory(dirPath) {
   await fsp.mkdir(dirPath, { recursive: true });
 }
@@ -299,10 +387,23 @@ async function replaceWithCopy(sourcePath, targetPath) {
   await fsp.cp(sourcePath, targetPath, { recursive: true, force: true });
 }
 
-async function installLinks({ toolkitHome, modes, env = process.env, previousSkillNames = [] }) {
+async function replaceWithSymlink(sourcePath, targetPath) {
+  await fsp.rm(targetPath, { recursive: true, force: true });
+  await ensureDirectory(path.dirname(targetPath));
+  await fsp.symlink(sourcePath, targetPath, process.platform === 'win32' ? 'junction' : 'dir');
+}
+
+// Install skills into target directories.
+// linkMode: 'copy' (default) or 'symlink'
+// includeExclusiveSkills: when true, non-codex targets also receive codex-exclusive skills.
+async function installLinks({ toolkitHome, modes, env = process.env, previousSkillNames = [], linkMode = 'copy', includeExclusiveSkills = false }) {
   const normalizedModes = normalizeModes(modes);
+  // Always collect codex skill names (needed when includeExclusiveSkills is true even
+  // when codex isn't in the target list).
+  const codexSkillNames = (normalizedModes.includes('codex') || includeExclusiveSkills)
+    ? await listCodexSkillNames(toolkitHome)
+    : [];
   const sharedSkillNames = await listSkillNames(toolkitHome);
-  const codexSkillNames = normalizedModes.includes('codex') ? await listCodexSkillNames(toolkitHome) : [];
   const skillNames = normalizedModes.includes('codex')
     ? [...new Set([...sharedSkillNames, ...codexSkillNames])].sort()
     : sharedSkillNames;
@@ -314,8 +415,18 @@ async function installLinks({ toolkitHome, modes, env = process.env, previousSki
       targetMode: target.mode,
       sharedSkillNames,
       codexSkillNames,
+      includeExclusiveSkills,
     });
-    const staleSkillNames = previousSkillNames.filter((skillName) => !targetSkillNames.includes(skillName));
+
+    // Read existing manifest to carry forward historical skills
+    const existingManifest = await readManifest(target.root);
+    const allPreviousSkills = existingManifest
+      ? [...new Set([...getManifestSkillNames(existingManifest), ...previousSkillNames.filter(isSafeSkillName)])]
+      : previousSkillNames.filter(isSafeSkillName);
+
+    const staleSkillNames = allPreviousSkills.filter(
+      (skillName) => !targetSkillNames.includes(skillName),
+    );
 
     await ensureDirectory(target.root);
     for (const staleSkillName of staleSkillNames) {
@@ -329,27 +440,89 @@ async function installLinks({ toolkitHome, modes, env = process.env, previousSki
         codexSkillNames,
       });
       const targetPath = path.join(target.root, skillName);
-      await replaceWithCopy(sourcePath, targetPath);
-      copiedPaths.push({ target: target.label, path: targetPath, skillName });
+
+      if (linkMode === 'symlink') {
+        await replaceWithSymlink(sourcePath, targetPath);
+      } else {
+        await replaceWithCopy(sourcePath, targetPath);
+      }
+      copiedPaths.push({ target: target.label, path: targetPath, skillName, linkMode });
     }
+
+    // Persist manifest for future uninstall / dedup
+    await writeManifest(target.root, {
+      version: existingManifest?.version || 'unknown',
+      linkMode,
+      skills: targetSkillNames,
+      previousSkills: allPreviousSkills,
+    });
   }
 
   return {
     skillNames,
     targets,
     copiedPaths,
+    linkMode,
   };
 }
 
+// Uninstall all skills from all target directories that have manifests.
+async function uninstallSkills({ env = process.env, modes = null } = {}) {
+  const normalizedModes = modes ? normalizeModes(modes) : VALID_MODES;
+  const targets = await getUninstallTargetRoots(normalizedModes, env);
+  const results = [];
+
+  for (const target of targets) {
+    const manifest = await readManifest(target.root);
+    if (!manifest) {
+      continue;
+    }
+
+    const skillNames = getManifestSkillNames(manifest);
+    const removedSkills = [];
+    for (const skillName of skillNames) {
+      const skillPath = path.join(target.root, skillName);
+      try {
+        await fsp.rm(skillPath, { recursive: true, force: true });
+        removedSkills.push(skillName);
+      } catch {
+        // Skip skills that couldn't be removed
+      }
+    }
+
+    // Remove the manifest itself
+    try {
+      await fsp.rm(path.join(target.root, MANIFEST_FILENAME), { force: true });
+    } catch {
+      // ok if already gone
+    }
+
+    results.push({
+      target: target.label,
+      root: target.root,
+      removedSkills,
+    });
+  }
+
+  return results;
+}
+
 module.exports = {
   expandUserPath,
   TARGET_DEFINITIONS,
   VALID_MODES,
+  MANIFEST_FILENAME,
   getTargetRoots,
+  getUninstallTargetRoots,
   installLinks,
+  listAllKnownSkillNames,
+  listCodexSkillNames,
   listSkillNames,
   normalizeModes,
+  readManifest,
   resolveHomeDirectory,
   resolveToolkitHome,
   syncToolkitHome,
+  uninstallSkills,
+  writeManifest,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laitszkin/apollo-toolkit",
-  "version": "3.2.2",
+  "version": "3.3.1",
   "description": "Apollo Toolkit npm installer for managed skill copying across Codex, OpenClaw, and Trae.",
   "license": "MIT",
   "author": "LaiTszKin",