@kaitranntt/ccs 7.55.0 → 7.56.0-dev.1

package/dist/management/shared-manager.js

@@ -29,27 +29,52 @@ 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");
-function normalizePluginMetadataPathString(input) {
-    return input.replace(/([\\/])\.ccs\1instances\1[^\\/]+\1/g, (_match, separator) => `${separator}.claude${separator}`);
+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) {
+function normalizePluginMetadataValue(value, targetConfigDir) {
     if (typeof value === 'string') {
-        const normalized = normalizePluginMetadataPathString(value);
+        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);
+            const result = normalizePluginMetadataValue(item, targetConfigDir);
             changed = changed || result.changed;
             return result.normalized;
         });
@@ -58,7 +83,7 @@ function normalizePluginMetadataValue(value) {
     if (value && typeof value === 'object') {
         let changed = false;
         const normalized = Object.fromEntries(Object.entries(value).map(([key, item]) => {
-            const result = normalizePluginMetadataValue(item);
+            const result = normalizePluginMetadataValue(item, targetConfigDir);
             changed = changed || result.changed;
             return [key, result.normalized];
         }));
@@ -66,9 +91,9 @@ function normalizePluginMetadataValue(value) {
     }
     return { normalized: value, changed: false };
 }
-function normalizePluginMetadataContent(original) {
+function normalizePluginMetadataContent(original, targetConfigDir = path.join(os.homedir(), '.claude')) {
     const parsed = JSON.parse(original);
-    const result = normalizePluginMetadataValue(parsed);
+    const result = normalizePluginMetadataValue(parsed, targetConfigDir);
     return result.changed ? JSON.stringify(result.normalized, null, 2) : original;
 }
 exports.normalizePluginMetadataContent = normalizePluginMetadataContent;
@@ -77,6 +102,12 @@ exports.normalizePluginMetadataContent = normalizePluginMetadataContent;
  */
 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',
@@ -88,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' },
@@ -142,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);
@@ -212,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';
@@ -246,6 +275,128 @@ class SharedManager {
         }
         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.
      *
@@ -473,12 +624,17 @@ class SharedManager {
         }
     }
     /**
-     * Normalize shared plugin metadata files to canonical ~/.claude/ paths.
+     * 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.
@@ -490,14 +646,22 @@ class SharedManager {
         this.normalizePluginMetadataFiles('installed_plugins.json', configDir, 'Normalized plugin registry paths', 'plugin registry');
     }
     /**
-     * Normalize marketplace registry paths to use canonical ~/.claude/ paths
-     * instead of instance-specific ~/.ccs/instances/<name>/ paths.
-     *
-     * This ensures known_marketplaces.json is consistent regardless of
-     * which CCS instance added the marketplace.
+     * Reconcile marketplace registry content into the active config dir while
+     * keeping the global ~/.claude copy up to date for non-instance flows.
      */
     normalizeMarketplaceRegistryPaths(configDir) {
-        this.normalizePluginMetadataFiles('known_marketplaces.json', configDir, 'Normalized marketplace registry paths', 'marketplace registry');
+        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();
@@ -536,6 +700,86 @@ class SharedManager {
             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/)
      * Runs once on upgrade
@@ -923,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);