@kaitranntt/ccs 7.54.0 → 7.55.0-dev.2

package/dist/management/shared-manager.d.ts

@@ -6,6 +6,8 @@
  * ~/.claude/ ← ~/.ccs/shared/ ← instance/
  */
 import { AccountContextPolicy } from '../auth/account-context';
+export declare function normalizePluginMetadataPathString(input: string, targetConfigDir?: string): string;
+export declare function normalizePluginMetadataContent(original: string, targetConfigDir?: string): string;
 /**
  * SharedManager Class
  */
@@ -14,7 +16,10 @@ declare class SharedManager {
     private readonly sharedDir;
     private readonly claudeDir;
     private readonly instancesDir;
+    private readonly pluginLayoutLock;
     private readonly sharedItems;
+    private readonly sharedPluginEntries;
+    private readonly instanceLocalPluginMetadataFiles;
     private readonly advancedContinuityItems;
     constructor();
     /**
@@ -30,6 +35,11 @@ declare class SharedManager {
      * Link shared directories to instance
      */
     linkSharedDirectories(instancePath: string): void;
+    detachSharedDirectories(instancePath: string): void;
+    private ensureSharedPluginLayoutDefaults;
+    private linkInstancePlugins;
+    private getSharedPluginLinkItems;
+    private removeExistingPath;
     /**
      * Sync project workspace context based on account policy.
      *
@@ -54,6 +64,11 @@ declare class SharedManager {
      *   ~/.ccs/shared/memory/<project>/
      */
     syncProjectMemories(instancePath: string): Promise<void>;
+    /**
+     * Normalize plugin metadata and reconcile marketplace metadata for the active config dir.
+     */
+    normalizeSharedPluginMetadataPaths(configDir?: string): void;
+    normalizeSharedPluginMetadataPathsLocked(configDir?: string): void;
     /**
      * Normalize plugin registry paths to use canonical ~/.claude/ paths
      * instead of instance-specific ~/.ccs/instances/<name>/ paths.
@@ -61,7 +76,19 @@ declare class SharedManager {
      * This ensures installed_plugins.json is consistent regardless of
      * which CCS instance installed the plugin.
      */
-    normalizePluginRegistryPaths(): void;
+    normalizePluginRegistryPaths(configDir?: string): void;
+    /**
+     * Reconcile marketplace registry content into the active config dir while
+     * keeping the global ~/.claude copy up to date for non-instance flows.
+     */
+    normalizeMarketplaceRegistryPaths(configDir?: string): void;
+    private normalizePluginMetadataFiles;
+    private getPluginMetadataFilePaths;
+    private normalizePluginMetadataFile;
+    private getMarketplaceRegistrySourcePaths;
+    private buildMarketplaceRegistryContent;
+    private discoverMarketplaceEntries;
+    private writePluginMetadataFile;
     /**
      * Migrate from v3.1.1 (copied data in ~/.ccs/shared/) to v3.2.0 (symlinks to ~/.claude/)
      * Runs once on upgrade
@@ -119,6 +146,9 @@ declare class SharedManager {
      * Build a non-destructive conflict copy path.
      */
     private getConflictCopyPath;
+    private symlinkPointsTo;
+    private detachManagedPluginLayout;
+    private reconcileLocalMarketplaceRegistry;
     private resolveCanonicalPath;
     private isPathWithinDirectory;
     private pathExists;

package/dist/management/shared-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared-manager.d.ts","sourceRoot":"","sources":["../../src/management/shared-manager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,EAAE,oBAAoB,EAAiC,MAAM,yBAAyB,CAAC;AAQ9F;;GAEG;AACH,cAAM,aAAa;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAe;IAC3C,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAKtC;;IAiBF;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAoC7B;;;OAGG;IACH,uBAAuB,IAAI,IAAI;IA8E/B;;OAEG;IACH,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAyCjD;;;;;OAKG;IACG,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAoG3F;;;;;OAKG;IACG,+BAA+B,CACnC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,IAAI,CAAC;IAsHhB;;;;;;;;OAQG;IACG,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmF9D;;;;;;OAMG;IACH,4BAA4B,IAAI,IAAI;IA4BpC;;;OAGG;IACH,eAAe,IAAI,IAAI;IAoGvB;;;OAGG;IACH,uBAAuB,IAAI,IAAI;IA4E/B;;;OAGG;YACW,uBAAuB;IAkCrC;;OAEG;YACW,eAAe;IAgB7B;;OAEG;YACW,wBAAwB;IAStC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAejC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IA6BnC;;OAEG;YACW,yBAAyB;IAmBvC;;;OAGG;YACW,6BAA6B;IAiD3C;;OAEG;YACW,aAAa;IAc3B;;;OAGG;YACW,gCAAgC;IA0C9C;;OAEG;YACW,iBAAiB;IAiB/B;;OAEG;YACW,mBAAmB;IAiBjC,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,qBAAqB;YAaf,UAAU;YASV,eAAe;YAIf,QAAQ;IAWtB;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAuB9B;AAED,eAAe,aAAa,CAAC"}
+{"version":3,"file":"shared-manager.d.ts","sourceRoot":"","sources":["../../src/management/shared-manager.ts"],"names":[],"mappings":"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"}

package/dist/management/shared-manager.js

@@ -29,18 +29,85 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePluginMetadataContent = exports.normalizePluginMetadataPathString = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const profile_context_sync_lock_1 = __importDefault(require("./profile-context-sync-lock"));
 const ui_1 = require("../utils/ui");
 const account_context_1 = require("../auth/account-context");
 const config_manager_1 = require("../utils/config-manager");
+const DEFAULT_INSTALLED_PLUGIN_REGISTRY = JSON.stringify({
+    version: 2,
+    plugins: {},
+}, null, 2);
+function getPluginPathModule(targetConfigDir, input) {
+    return targetConfigDir.includes('\\') || input.includes('\\') ? path.win32 : path.posix;
+}
+function normalizeTargetConfigDir(targetConfigDir, input) {
+    const pathModule = getPluginPathModule(targetConfigDir, input);
+    return pathModule.normalize(pathModule === path.win32
+        ? targetConfigDir.replace(/\//g, '\\')
+        : targetConfigDir.replace(/\\/g, '/'));
+}
+function normalizePluginMetadataPathString(input, targetConfigDir = path.join(os.homedir(), '.claude')) {
+    const match = input.match(/^(.*?)([\\/])(?:\.claude|\.ccs\2shared|\.ccs\2instances\2[^\\/]+)\2plugins(?:(\2.*))?$/);
+    if (!match) {
+        return input;
+    }
+    const pathModule = getPluginPathModule(targetConfigDir, input);
+    const normalizedTargetConfigDir = normalizeTargetConfigDir(targetConfigDir, input);
+    const suffix = match[3] ?? '';
+    const suffixSegments = suffix.split(/[\\/]+/).filter(Boolean);
+    return pathModule.join(normalizedTargetConfigDir, 'plugins', ...suffixSegments);
+}
+exports.normalizePluginMetadataPathString = normalizePluginMetadataPathString;
+function normalizePluginMetadataValue(value, targetConfigDir) {
+    if (typeof value === 'string') {
+        const normalized = normalizePluginMetadataPathString(value, targetConfigDir);
+        return { normalized, changed: normalized !== value };
+    }
+    if (Array.isArray(value)) {
+        let changed = false;
+        const normalized = value.map((item) => {
+            const result = normalizePluginMetadataValue(item, targetConfigDir);
+            changed = changed || result.changed;
+            return result.normalized;
+        });
+        return { normalized, changed };
+    }
+    if (value && typeof value === 'object') {
+        let changed = false;
+        const normalized = Object.fromEntries(Object.entries(value).map(([key, item]) => {
+            const result = normalizePluginMetadataValue(item, targetConfigDir);
+            changed = changed || result.changed;
+            return [key, result.normalized];
+        }));
+        return { normalized, changed };
+    }
+    return { normalized: value, changed: false };
+}
+function normalizePluginMetadataContent(original, targetConfigDir = path.join(os.homedir(), '.claude')) {
+    const parsed = JSON.parse(original);
+    const result = normalizePluginMetadataValue(parsed, targetConfigDir);
+    return result.changed ? JSON.stringify(result.normalized, null, 2) : original;
+}
+exports.normalizePluginMetadataContent = normalizePluginMetadataContent;
 /**
  * SharedManager Class
  */
 class SharedManager {
     constructor() {
+        this.sharedPluginEntries = [
+            { name: 'cache', type: 'directory' },
+            { name: 'marketplaces', type: 'directory' },
+            { name: 'installed_plugins.json', type: 'file' },
+        ];
+        this.instanceLocalPluginMetadataFiles = new Set(['known_marketplaces.json']);
         this.advancedContinuityItems = [
             'session-env',
             'file-history',
@@ -52,6 +119,7 @@ class SharedManager {
         this.sharedDir = path.join(ccsDir, 'shared');
         this.claudeDir = path.join(this.homeDir, '.claude');
         this.instancesDir = path.join(ccsDir, 'instances');
+        this.pluginLayoutLock = new profile_context_sync_lock_1.default(this.instancesDir);
         this.sharedItems = [
             { name: 'commands', type: 'directory' },
             { name: 'skills', type: 'directory' },
@@ -106,6 +174,7 @@ class SharedManager {
         if (!fs.existsSync(this.sharedDir)) {
             fs.mkdirSync(this.sharedDir, { recursive: true, mode: 0o700 });
         }
+        this.ensureSharedPluginLayoutDefaults();
         // Create symlinks ~/.ccs/shared/* → ~/.claude/*
         for (const item of this.sharedItems) {
             const claudePath = path.join(this.claudeDir, item.name);
@@ -176,17 +245,13 @@ class SharedManager {
     linkSharedDirectories(instancePath) {
         this.ensureSharedDirectories();
         for (const item of this.sharedItems) {
+            if (item.name === 'plugins') {
+                this.linkInstancePlugins(instancePath);
+                continue;
+            }
             const linkPath = path.join(instancePath, item.name);
             const targetPath = path.join(this.sharedDir, item.name);
-            // Remove existing file/directory/link
-            if (fs.existsSync(linkPath)) {
-                if (item.type === 'directory') {
-                    fs.rmSync(linkPath, { recursive: true, force: true });
-                }
-                else {
-                    fs.unlinkSync(linkPath);
-                }
-            }
+            this.removeExistingPath(linkPath, item.type);
             // Create symlink
             try {
                 const symlinkType = item.type === 'directory' ? 'dir' : 'file';
@@ -208,8 +273,129 @@ class SharedManager {
                 }
             }
         }
-        // Normalize plugin registry paths after linking
-        this.normalizePluginRegistryPaths();
+        this.normalizeSharedPluginMetadataPaths(instancePath);
+    }
+    detachSharedDirectories(instancePath) {
+        this.ensureSharedDirectories();
+        for (const item of this.sharedItems) {
+            const managedPath = path.join(instancePath, item.name);
+            if (!fs.existsSync(managedPath)) {
+                continue;
+            }
+            if (item.name === 'plugins') {
+                this.detachManagedPluginLayout(instancePath);
+                continue;
+            }
+            const stats = fs.lstatSync(managedPath);
+            if (!stats.isSymbolicLink()) {
+                continue;
+            }
+            if (this.symlinkPointsTo(managedPath, path.join(this.sharedDir, item.name))) {
+                this.removeExistingPath(managedPath, item.type);
+            }
+        }
+    }
+    ensureSharedPluginLayoutDefaults() {
+        const pluginsDir = path.join(this.claudeDir, 'plugins');
+        fs.mkdirSync(pluginsDir, { recursive: true, mode: 0o700 });
+        for (const entry of this.sharedPluginEntries) {
+            const entryPath = path.join(pluginsDir, entry.name);
+            if (fs.existsSync(entryPath)) {
+                continue;
+            }
+            if (entry.type === 'directory') {
+                fs.mkdirSync(entryPath, { recursive: true, mode: 0o700 });
+                continue;
+            }
+            fs.writeFileSync(entryPath, DEFAULT_INSTALLED_PLUGIN_REGISTRY, 'utf8');
+        }
+        const marketplaceRegistryPath = path.join(pluginsDir, 'known_marketplaces.json');
+        if (!fs.existsSync(marketplaceRegistryPath)) {
+            fs.writeFileSync(marketplaceRegistryPath, JSON.stringify({}, null, 2), 'utf8');
+        }
+    }
+    linkInstancePlugins(instancePath) {
+        const linkPath = path.join(instancePath, 'plugins');
+        const targetPath = path.join(this.sharedDir, 'plugins');
+        let linkStats = null;
+        try {
+            linkStats = fs.lstatSync(linkPath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+        }
+        if (linkStats?.isSymbolicLink() || (linkStats && !linkStats.isDirectory())) {
+            this.removeExistingPath(linkPath, linkStats.isDirectory() ? 'directory' : 'file');
+        }
+        if (!linkStats || !linkStats.isDirectory()) {
+            fs.mkdirSync(linkPath, { recursive: true, mode: 0o700 });
+        }
+        for (const item of this.getSharedPluginLinkItems()) {
+            const targetEntryPath = path.join(targetPath, item.name);
+            const linkEntryPath = path.join(linkPath, item.name);
+            this.removeExistingPath(linkEntryPath, item.type);
+            try {
+                const symlinkType = item.type === 'directory' ? 'dir' : 'file';
+                fs.symlinkSync(targetEntryPath, linkEntryPath, symlinkType);
+            }
+            catch (_err) {
+                if (process.platform === 'win32') {
+                    if (item.type === 'directory') {
+                        this.copyDirectoryFallback(targetEntryPath, linkEntryPath);
+                    }
+                    else {
+                        fs.copyFileSync(targetEntryPath, linkEntryPath);
+                    }
+                    console.log((0, ui_1.warn)(`Symlink failed for plugins/${item.name}, copied instead (enable Developer Mode)`));
+                }
+                else {
+                    throw _err;
+                }
+            }
+        }
+    }
+    getSharedPluginLinkItems() {
+        const sharedPluginsPath = path.join(this.sharedDir, 'plugins');
+        const items = new Map(this.sharedPluginEntries.map((entry) => [entry.name, { ...entry }]));
+        for (const entry of fs.readdirSync(sharedPluginsPath, { withFileTypes: true })) {
+            if (items.has(entry.name) || this.instanceLocalPluginMetadataFiles.has(entry.name)) {
+                continue;
+            }
+            const entryPath = path.join(sharedPluginsPath, entry.name);
+            const stats = fs.statSync(entryPath);
+            items.set(entry.name, {
+                name: entry.name,
+                type: stats.isDirectory() ? 'directory' : 'file',
+            });
+        }
+        return [...items.values()];
+    }
+    removeExistingPath(targetPath, typeHint) {
+        try {
+            const stats = fs.lstatSync(targetPath);
+            if (stats.isDirectory() && !stats.isSymbolicLink()) {
+                fs.rmSync(targetPath, { recursive: true, force: true });
+                return;
+            }
+            if (stats.isSymbolicLink() || typeHint === 'file') {
+                fs.unlinkSync(targetPath);
+                return;
+            }
+            fs.rmSync(targetPath, { recursive: true, force: true });
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                return;
+            }
+            if (typeHint === 'directory') {
+                fs.rmSync(targetPath, { recursive: true, force: true });
+            }
+            else {
+                fs.rmSync(targetPath, { force: true });
+            }
+        }
     }
     /**
      * Sync project workspace context based on account policy.
@@ -437,6 +623,18 @@ class SharedManager {
             console.log((0, ui_1.ok)(`Synced shared project memory: ${migrated} migrated, ${merged} merged conflict(s), ${linked} linked`));
         }
     }
+    /**
+     * Normalize plugin metadata and reconcile marketplace metadata for the active config dir.
+     */
+    normalizeSharedPluginMetadataPaths(configDir) {
+        this.normalizePluginRegistryPaths(configDir);
+        this.normalizeMarketplaceRegistryPaths(configDir);
+    }
+    normalizeSharedPluginMetadataPathsLocked(configDir) {
+        this.pluginLayoutLock.withNamedLockSync('__plugin-layout__', () => {
+            this.normalizeSharedPluginMetadataPaths(configDir);
+        });
+    }
     /**
      * Normalize plugin registry paths to use canonical ~/.claude/ paths
      * instead of instance-specific ~/.ccs/instances/<name>/ paths.
@@ -444,29 +642,143 @@ class SharedManager {
      * This ensures installed_plugins.json is consistent regardless of
      * which CCS instance installed the plugin.
      */
-    normalizePluginRegistryPaths() {
-        const registryPath = path.join(this.claudeDir, 'plugins', 'installed_plugins.json');
-        // Skip if registry doesn't exist
+    normalizePluginRegistryPaths(configDir) {
+        this.normalizePluginMetadataFiles('installed_plugins.json', configDir, 'Normalized plugin registry paths', 'plugin registry');
+    }
+    /**
+     * Reconcile marketplace registry content into the active config dir while
+     * keeping the global ~/.claude copy up to date for non-instance flows.
+     */
+    normalizeMarketplaceRegistryPaths(configDir) {
+        const successMessage = 'Synchronized marketplace registry paths';
+        const warningLabel = 'marketplace registry';
+        try {
+            const sourcePaths = this.getMarketplaceRegistrySourcePaths(configDir);
+            this.writePluginMetadataFile(path.join(this.claudeDir, 'plugins', 'known_marketplaces.json'), this.buildMarketplaceRegistryContent(sourcePaths, this.claudeDir), successMessage);
+            if (configDir && path.resolve(configDir) !== path.resolve(this.claudeDir)) {
+                this.writePluginMetadataFile(path.join(configDir, 'plugins', 'known_marketplaces.json'), this.buildMarketplaceRegistryContent(sourcePaths, configDir), successMessage);
+            }
+        }
+        catch (err) {
+            console.log((0, ui_1.warn)(`Could not synchronize ${warningLabel}: ${err.message}`));
+        }
+    }
+    normalizePluginMetadataFiles(fileName, configDir, successMessage, warningLabel) {
+        const seen = new Set();
+        for (const registryPath of this.getPluginMetadataFilePaths(fileName, configDir)) {
+            const dedupeKey = this.resolveCanonicalPath(registryPath);
+            if (seen.has(dedupeKey)) {
+                continue;
+            }
+            seen.add(dedupeKey);
+            this.normalizePluginMetadataFile(registryPath, successMessage, warningLabel);
+        }
+    }
+    getPluginMetadataFilePaths(fileName, configDir) {
+        const pluginDirs = new Set([
+            path.join(this.claudeDir, 'plugins'),
+            path.join(this.sharedDir, 'plugins'),
+        ]);
+        if (configDir && path.resolve(configDir) !== path.resolve(this.claudeDir)) {
+            pluginDirs.add(path.join(configDir, 'plugins'));
+        }
+        return [...pluginDirs].map((pluginDir) => path.join(pluginDir, fileName));
+    }
+    normalizePluginMetadataFile(registryPath, successMessage, warningLabel) {
         if (!fs.existsSync(registryPath)) {
             return;
         }
         try {
             const original = fs.readFileSync(registryPath, 'utf8');
-            // Replace instance paths with canonical claude path
-            // Pattern: /.ccs/instances/<instance-name>/ -> /.claude/
-            const normalized = original.replace(/\/\.ccs\/instances\/[^/]+\//g, '/.claude/');
-            // Only write if changes were made
+            const normalized = normalizePluginMetadataContent(original);
             if (normalized !== original) {
-                // Validate JSON before writing
-                JSON.parse(normalized);
                 fs.writeFileSync(registryPath, normalized, 'utf8');
-                console.log((0, ui_1.ok)('Normalized plugin registry paths'));
+                console.log((0, ui_1.ok)(successMessage));
             }
         }
         catch (err) {
-            // Log warning but don't fail - registry may be malformed
-            console.log((0, ui_1.warn)(`Could not normalize plugin registry: ${err.message}`));
+            console.log((0, ui_1.warn)(`Could not normalize ${warningLabel}: ${err.message}`));
+        }
+    }
+    getMarketplaceRegistrySourcePaths(configDir) {
+        const sourcePaths = new Set([
+            path.join(this.claudeDir, 'plugins', 'known_marketplaces.json'),
+        ]);
+        if (fs.existsSync(this.instancesDir)) {
+            for (const entry of fs.readdirSync(this.instancesDir, { withFileTypes: true })) {
+                if (!entry.isDirectory() || entry.name.startsWith('.')) {
+                    continue;
+                }
+                sourcePaths.add(path.join(this.instancesDir, entry.name, 'plugins', 'known_marketplaces.json'));
+            }
+        }
+        if (configDir && path.resolve(configDir) !== path.resolve(this.claudeDir)) {
+            sourcePaths.add(path.join(configDir, 'plugins', 'known_marketplaces.json'));
+        }
+        return [...sourcePaths];
+    }
+    buildMarketplaceRegistryContent(sourcePaths, targetConfigDir) {
+        const merged = {};
+        for (const registryPath of sourcePaths) {
+            if (!fs.existsSync(registryPath)) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                    continue;
+                }
+                for (const [name, value] of Object.entries(parsed)) {
+                    merged[name] = normalizePluginMetadataValue(value, targetConfigDir).normalized;
+                }
+            }
+            catch (err) {
+                console.log((0, ui_1.warn)(`Skipping malformed marketplace registry ${registryPath}: ${err.message}`));
+            }
+        }
+        const discoveredEntries = this.discoverMarketplaceEntries(targetConfigDir);
+        for (const [name, value] of Object.entries(discoveredEntries)) {
+            const existing = merged[name];
+            if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+                merged[name] = {
+                    ...existing,
+                    installLocation: value.installLocation,
+                };
+                continue;
+            }
+            merged[name] = value;
+        }
+        for (const name of Object.keys(merged)) {
+            if (!(name in discoveredEntries)) {
+                delete merged[name];
+            }
+        }
+        return JSON.stringify(merged, null, 2);
+    }
+    discoverMarketplaceEntries(targetConfigDir) {
+        const marketplacesDir = path.join(targetConfigDir, 'plugins', 'marketplaces');
+        if (!fs.existsSync(marketplacesDir)) {
+            return {};
+        }
+        const discovered = {};
+        for (const entry of fs.readdirSync(marketplacesDir, { withFileTypes: true })) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            discovered[entry.name] = {
+                installLocation: path.join(targetConfigDir, 'plugins', 'marketplaces', entry.name),
+            };
+        }
+        return discovered;
+    }
+    writePluginMetadataFile(registryPath, content, successMessage) {
+        fs.mkdirSync(path.dirname(registryPath), { recursive: true, mode: 0o700 });
+        const current = fs.existsSync(registryPath) ? fs.readFileSync(registryPath, 'utf8') : null;
+        if (current === content) {
+            return;
         }
+        fs.writeFileSync(registryPath, content, 'utf8');
+        console.log((0, ui_1.ok)(successMessage));
     }
     /**
      * Migrate from v3.1.1 (copied data in ~/.ccs/shared/) to v3.2.0 (symlinks to ~/.claude/)
@@ -855,6 +1167,91 @@ class SharedManager {
         }
         return candidate;
     }
+    symlinkPointsTo(linkPath, expectedTarget) {
+        try {
+            const currentTarget = fs.readlinkSync(linkPath);
+            const resolvedCurrentTarget = path.resolve(path.dirname(linkPath), currentTarget);
+            return (this.resolveCanonicalPath(resolvedCurrentTarget) ===
+                this.resolveCanonicalPath(expectedTarget));
+        }
+        catch {
+            return false;
+        }
+    }
+    detachManagedPluginLayout(instancePath) {
+        const pluginsPath = path.join(instancePath, 'plugins');
+        if (!fs.existsSync(pluginsPath)) {
+            return;
+        }
+        const stats = fs.lstatSync(pluginsPath);
+        const sharedPluginsPath = path.join(this.sharedDir, 'plugins');
+        if (stats.isSymbolicLink()) {
+            if (this.symlinkPointsTo(pluginsPath, sharedPluginsPath)) {
+                this.removeExistingPath(pluginsPath, 'directory');
+            }
+            return;
+        }
+        if (!stats.isDirectory()) {
+            return;
+        }
+        let removedManagedEntries = false;
+        for (const item of this.getSharedPluginLinkItems()) {
+            const pluginEntryPath = path.join(pluginsPath, item.name);
+            if (!fs.existsSync(pluginEntryPath)) {
+                continue;
+            }
+            const entryStats = fs.lstatSync(pluginEntryPath);
+            if (!entryStats.isSymbolicLink()) {
+                continue;
+            }
+            if (this.symlinkPointsTo(pluginEntryPath, path.join(sharedPluginsPath, item.name))) {
+                this.removeExistingPath(pluginEntryPath, item.type);
+                removedManagedEntries = true;
+            }
+        }
+        if (!removedManagedEntries) {
+            return;
+        }
+        this.reconcileLocalMarketplaceRegistry(instancePath);
+        if (fs.readdirSync(pluginsPath).length === 0) {
+            fs.rmSync(pluginsPath, { recursive: true, force: true });
+        }
+    }
+    reconcileLocalMarketplaceRegistry(configDir) {
+        const registryPath = path.join(configDir, 'plugins', 'known_marketplaces.json');
+        if (!fs.existsSync(registryPath)) {
+            return;
+        }
+        const discoveredEntries = this.discoverMarketplaceEntries(configDir);
+        if (Object.keys(discoveredEntries).length === 0) {
+            this.removeExistingPath(registryPath, 'file');
+            return;
+        }
+        let parsed = {};
+        try {
+            const raw = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+            if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+                parsed = raw;
+            }
+        }
+        catch {
+            parsed = {};
+        }
+        const reconciled = Object.fromEntries(Object.entries(discoveredEntries).map(([name, value]) => {
+            const existing = parsed[name];
+            if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+                return [
+                    name,
+                    {
+                        ...normalizePluginMetadataValue(existing, configDir).normalized,
+                        installLocation: value.installLocation,
+                    },
+                ];
+            }
+            return [name, value];
+        }));
+        this.writePluginMetadataFile(registryPath, JSON.stringify(reconciled, null, 2), 'Synchronized marketplace registry paths');
+    }
     resolveCanonicalPath(targetPath) {
         try {
             return fs.realpathSync.native(targetPath);