@cubis/foundry 0.3.55 → 0.3.57

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.3.57] - 2026-03-05
+
+### Changed
+
+- Refined `cbx init` welcome banner to a cleaner terminal layout with improved spacing and branding readability.
+- Removed placeholder banner text and replaced it with final Cubis Foundry ASCII presentation.
+
+## [0.3.56] - 2026-03-05
+
+### Fixed
+
+- Improved `cbx remove all` cleanup coverage:
+  - removes CBX-managed skills from all configured profile path candidates (not just a single preferred path)
+  - includes legacy Codex skill path cleanup (`~/.codex/skills`) for managed artifacts
+  - removes empty global CBX roots (`~/.cbx`, `~/.agents`) after cleanup when eligible.
+- Ensured global remove flow clears CBX-managed profile/config artifacts consistently (`~/.cbx/cbx_config.json`, `~/.cbx/state.json`, `~/.cbx/credentials.env` when present).
+
 ## [0.3.55] - 2026-03-05
 
 ### Added

package/dist/cli/core.js

@@ -2246,6 +2246,45 @@ async function resolveProfilePaths(profileId, scope, cwd = process.cwd()) {
         ruleFilesByPriority: cfg.ruleFilesByPriority.map((filePath) => expandPath(filePath, cwd)),
     };
 }
+function expandUniquePaths(pathList, cwd = process.cwd()) {
+    const seen = new Set();
+    const output = [];
+    for (const value of pathList || []) {
+        const normalized = String(value || "").trim();
+        if (!normalized)
+            continue;
+        const expanded = expandPath(normalized, cwd);
+        const key = path.resolve(expanded);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        output.push(expanded);
+    }
+    return output;
+}
+function resolveProfilePathCandidates(profileId, scope, cwd = process.cwd()) {
+    const profile = WORKFLOW_PROFILES[profileId];
+    if (!profile)
+        throw new Error(`Unknown platform '${profileId}'.`);
+    const cfg = profile[scope];
+    return {
+        workflowsDirs: expandUniquePaths(cfg.workflowDirs, cwd),
+        agentsDirs: expandUniquePaths(cfg.agentDirs, cwd),
+        skillsDirs: expandUniquePaths(cfg.skillDirs, cwd),
+        commandsDirs: expandUniquePaths(cfg.commandDirs, cwd),
+        promptsDirs: expandUniquePaths(cfg.promptDirs, cwd),
+        ruleFilesByPriority: expandUniquePaths(cfg.ruleFilesByPriority, cwd),
+    };
+}
+function resolveLegacySkillDirsForCleanup(platform, scope, cwd = process.cwd()) {
+    if (platform !== "codex")
+        return [];
+    if (scope === "global") {
+        return [path.join(os.homedir(), ".codex", "skills")];
+    }
+    const workspaceRoot = findWorkspaceRoot(cwd);
+    return [path.join(workspaceRoot, ".codex", "skills")];
+}
 async function resolveArtifactProfilePaths(profileId, scope, cwd = process.cwd()) {
     const scopedPaths = await resolveProfilePaths(profileId, scope, cwd);
     if (scope !== "global")
@@ -6480,6 +6519,35 @@ async function removePathRecord({ targetPath, category, dryRun = false, records,
         });
     }
 }
+async function removeEmptyDirectoryRecord({ dirPath, category, dryRun = false, records, }) {
+    if (!dirPath)
+        return;
+    if (!(await pathExists(dirPath)))
+        return;
+    let entries = [];
+    try {
+        entries = await readdir(dirPath);
+    }
+    catch {
+        return;
+    }
+    if (entries.length > 0)
+        return;
+    if (dryRun) {
+        records.push({
+            path: dirPath,
+            category,
+            action: "would-remove",
+        });
+        return;
+    }
+    await rm(dirPath, { recursive: true, force: true });
+    records.push({
+        path: dirPath,
+        category,
+        action: "removed",
+    });
+}
 async function removeMcpRuntimeEntriesJson({ filePath, keyName, serverIds, dryRun = false, }) {
     if (!(await pathExists(filePath))) {
         return { path: filePath, action: "missing", warnings: [] };
@@ -6617,6 +6685,7 @@ async function runWorkflowRemoveAll(options) {
         const scopes = resolveRemoveAllScopes(opts.scope);
         const platforms = resolveRemoveAllPlatforms(opts.platform);
         const bundleIds = await listBundleIds();
+        const knownTopLevelSkillIds = await listTopLevelSkillIdsFromRoot(workflowSkillsRoot());
         if (!dryRun && !opts.yes && process.stdin.isTTY) {
             const proceed = await confirm({
                 message: `Remove ALL CBX-managed artifacts for platforms [${platforms.join(", ")}] and scopes [${scopes.join(", ")}]?`,
@@ -6633,7 +6702,20 @@ async function runWorkflowRemoveAll(options) {
         const warnings = [];
         for (const scope of scopes) {
             for (const platform of platforms) {
-                const artifactProfilePaths = await resolveArtifactProfilePaths(platform, scope, cwd);
+                const artifactProfilePaths = await resolveProfilePaths(platform, scope, cwd);
+                const profileCandidates = resolveProfilePathCandidates(platform, scope, cwd);
+                const legacySkillDirs = resolveLegacySkillDirsForCleanup(platform, scope, cwd);
+                const allSkillDirs = expandUniquePaths([...profileCandidates.skillsDirs, ...legacySkillDirs], cwd);
+                const isPrimaryDir = (candidateDir, primaryDir) => {
+                    if (!candidateDir || !primaryDir)
+                        return false;
+                    return path.resolve(candidateDir) === path.resolve(primaryDir);
+                };
+                const alternateWorkflowsDirs = profileCandidates.workflowsDirs.filter((dirPath) => !isPrimaryDir(dirPath, artifactProfilePaths.workflowsDir));
+                const alternateAgentsDirs = profileCandidates.agentsDirs.filter((dirPath) => !isPrimaryDir(dirPath, artifactProfilePaths.agentsDir));
+                const alternateCommandsDirs = profileCandidates.commandsDirs.filter((dirPath) => !isPrimaryDir(dirPath, artifactProfilePaths.commandsDir));
+                const alternatePromptsDirs = profileCandidates.promptsDirs.filter((dirPath) => !isPrimaryDir(dirPath, artifactProfilePaths.promptsDir));
+                const alternateSkillsDirs = allSkillDirs.filter((dirPath) => !isPrimaryDir(dirPath, artifactProfilePaths.skillsDir));
                 for (const bundleId of bundleIds) {
                     const manifest = await readBundleManifest(bundleId);
                     const removedBundle = await removeBundleArtifacts({
@@ -6652,19 +6734,91 @@ async function runWorkflowRemoveAll(options) {
                             action: dryRun ? "would-remove" : "removed",
                         });
                     }
-                }
-                const extraSkillPaths = [
-                    path.join(artifactProfilePaths.skillsDir || "", POSTMAN_SKILL_ID),
-                    path.join(artifactProfilePaths.skillsDir || "", STITCH_SKILL_ID),
-                    path.join(artifactProfilePaths.skillsDir || "", "skills_index.json"),
-                ];
-                for (const extraPath of extraSkillPaths) {
-                    await removePathRecord({
-                        targetPath: extraPath,
-                        category: `${platform}/${scope}/extra-skill`,
-                        dryRun,
-                        records: removedRecords,
+                    const platformSpec = manifest.platforms?.[platform];
+                    if (!platformSpec)
+                        continue;
+                    const workflowFiles = (platformSpec.workflows || []).map((entry) => path.basename(entry));
+                    const agentFiles = (platformSpec.agents || []).map((entry) => path.basename(entry));
+                    const commandFiles = (platformSpec.commands || []).map((entry) => path.basename(entry));
+                    const promptFiles = (platformSpec.prompts || []).map((entry) => path.basename(entry));
+                    const skillIds = await resolveInstallSkillIds({
+                        platformSpec,
+                        extraSkillIds: [],
                     });
+                    const wrapperSkillIds = platform === "codex" ? buildCodexWrapperSkillIds(platformSpec) : [];
+                    const bundleSkillIds = [...new Set([...skillIds, ...wrapperSkillIds])];
+                    for (const workflowsDir of alternateWorkflowsDirs) {
+                        for (const workflowFile of workflowFiles) {
+                            await removePathRecord({
+                                targetPath: path.join(workflowsDir, workflowFile),
+                                category: `${platform}/${scope}/bundle-alt`,
+                                dryRun,
+                                records: removedRecords,
+                            });
+                        }
+                    }
+                    for (const agentsDir of alternateAgentsDirs) {
+                        for (const agentFile of agentFiles) {
+                            await removePathRecord({
+                                targetPath: path.join(agentsDir, agentFile),
+                                category: `${platform}/${scope}/bundle-alt`,
+                                dryRun,
+                                records: removedRecords,
+                            });
+                        }
+                    }
+                    for (const commandsDir of alternateCommandsDirs) {
+                        for (const commandFile of commandFiles) {
+                            await removePathRecord({
+                                targetPath: path.join(commandsDir, commandFile),
+                                category: `${platform}/${scope}/bundle-alt`,
+                                dryRun,
+                                records: removedRecords,
+                            });
+                        }
+                    }
+                    for (const promptsDir of alternatePromptsDirs) {
+                        for (const promptFile of promptFiles) {
+                            await removePathRecord({
+                                targetPath: path.join(promptsDir, promptFile),
+                                category: `${platform}/${scope}/bundle-alt`,
+                                dryRun,
+                                records: removedRecords,
+                            });
+                        }
+                    }
+                    for (const skillsDir of alternateSkillsDirs) {
+                        for (const skillId of bundleSkillIds) {
+                            await removePathRecord({
+                                targetPath: path.join(skillsDir, skillId),
+                                category: `${platform}/${scope}/bundle-alt`,
+                                dryRun,
+                                records: removedRecords,
+                            });
+                        }
+                    }
+                }
+                for (const skillsDir of allSkillDirs) {
+                    for (const entry of [
+                        POSTMAN_SKILL_ID,
+                        STITCH_SKILL_ID,
+                        "skills_index.json",
+                    ]) {
+                        await removePathRecord({
+                            targetPath: path.join(skillsDir, entry),
+                            category: `${platform}/${scope}/extra-skill`,
+                            dryRun,
+                            records: removedRecords,
+                        });
+                    }
+                    for (const skillId of knownTopLevelSkillIds) {
+                        await removePathRecord({
+                            targetPath: path.join(skillsDir, skillId),
+                            category: `${platform}/${scope}/known-skill`,
+                            dryRun,
+                            records: removedRecords,
+                        });
+                    }
                 }
                 if (platform === "antigravity") {
                     const terminalCleanup = await cleanupAntigravityTerminalIntegration({
@@ -6710,6 +6864,21 @@ async function runWorkflowRemoveAll(options) {
                         warnings.push(...runtimeResult.warnings);
                     }
                 }
+                for (const managedDir of expandUniquePaths([
+                    ...profileCandidates.skillsDirs,
+                    ...profileCandidates.agentsDirs,
+                    ...profileCandidates.workflowsDirs,
+                    ...profileCandidates.commandsDirs,
+                    ...profileCandidates.promptsDirs,
+                    ...legacySkillDirs,
+                ], cwd)) {
+                    await removeEmptyDirectoryRecord({
+                        dirPath: managedDir,
+                        category: `${platform}/${scope}/managed-dir-empty`,
+                        dryRun,
+                        records: removedRecords,
+                    });
+                }
                 const scopedProfilePaths = await resolveProfilePaths(platform, scope, cwd);
                 const ruleCandidates = [...scopedProfilePaths.ruleFilesByPriority];
                 if (scope === "global") {
@@ -6772,7 +6941,7 @@ async function runWorkflowRemoveAll(options) {
                     records: removedRecords,
                 });
             }
-            else if (includeCredentials) {
+            else if (scope === "global" || includeCredentials) {
                 await removePathRecord({
                     targetPath: resolveManagedCredentialsEnvPath(),
                     category: "global/credentials",
@@ -6780,6 +6949,19 @@ async function runWorkflowRemoveAll(options) {
                     records: removedRecords,
                 });
             }
+            if (scope === "global") {
+                for (const globalRootDir of [
+                    path.join(os.homedir(), ".cbx"),
+                    path.join(os.homedir(), ".agents"),
+                ]) {
+                    await removeEmptyDirectoryRecord({
+                        dirPath: globalRootDir,
+                        category: "global/root-dir-empty",
+                        dryRun,
+                        records: removedRecords,
+                    });
+                }
+            }
         }
         if (await checkDockerAvailable({ cwd })) {
             const containerName = DEFAULT_MCP_DOCKER_CONTAINER_NAME;