cray-code 1.0.0

package/dist/plugins/registry.js

@@ -0,0 +1,695 @@
+/**
+ * Plugin System for Cray Code.
+ *
+ * Mirrors Claude Code's plugin architecture: plugins are directories under
+ * .cray/plugins/<name>/ containing:
+ *   manifest.json  — required: { name, version, description }
+ *   commands/      — optional: *.md files = plugin commands
+ *   skills/        — optional: <skill-name>/SKILL.md = plugin skills
+ *   mcp.json       — optional: { servers: { ... } }
+ *   hooks.js       — optional: { onSessionStart, onSessionEnd, ... }
+ *
+ * Plugins are auto-discovered at startup. Plugin skills/commands are
+ * converted to SkillInfo objects and merged into the global skill list.
+ *
+ * Commands:
+ *   /plugin list              — show installed plugins
+ *   /plugin install <path>    — install a plugin from a local directory
+ *   /plugin remove <name>     — remove an installed plugin
+ *   /plugin enable <name>     — enable a disabled plugin
+ *   /plugin disable <name>    — disable a plugin
+ *   /plugin info <name>       — show plugin details
+ */
+import { existsSync, readdirSync, statSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmdirSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+import { execFileSync } from 'child_process';
+import { pathToFileURL } from 'url';
+import { discoverAllPlugins } from '../services/loadPluginCommands.js';
+// Re-export for external consumers
+export { discoverAllPlugins };
+const plugins = new Map();
+const loadedFromPaths = new Set();
+// ─── Path Helpers ─────────────────────────────────────────────────────
+function getUserPluginDir() {
+    return join(homedir(), '.cray', 'plugins');
+}
+function getProjectPluginDir(cwd) {
+    return join(cwd, '.cray', 'plugins');
+}
+function getAllPluginSearchDirs(projectRoot) {
+    const dirs = [getUserPluginDir()];
+    if (projectRoot)
+        dirs.push(getProjectPluginDir(projectRoot));
+    return dirs;
+}
+// ─── Registration ─────────────────────────────────────────────────────
+export function registerPlugin(plugin) {
+    plugins.set(plugin.manifest.name, plugin);
+    loadedFromPaths.add(plugin.dir);
+}
+export function unregisterPlugin(name) {
+    const p = plugins.get(name);
+    if (p)
+        loadedFromPaths.delete(p.dir);
+    return plugins.delete(name);
+}
+export function getEnabledPlugins() {
+    return [...plugins.values()].filter(p => p.isEnabled());
+}
+export function getAllPlugins() {
+    return [...plugins.values()];
+}
+export function getPlugin(name) {
+    return plugins.get(name);
+}
+// ─── Skill/Command/MCP Extraction ─────────────────────────────────────
+/**
+ * Get all skills from enabled plugins.
+ * Plugin skills follow the same SkillInfo type as bundled/disk skills,
+ * so they automatically appear in the SkillTool's available list and
+ * the system prompt's skill listing.
+ */
+export function getPluginSkills() {
+    return getEnabledPlugins().flatMap(p => p.skills);
+}
+/**
+ * Get all commands from enabled plugins.
+ */
+export function getPluginCommands() {
+    return getEnabledPlugins().flatMap(p => p.commands);
+}
+/**
+ * Get MCP server configs from enabled plugins.
+ * Prefixed with plugin name to avoid collisions: e.g. "myplugin::myserver"
+ */
+export function getPluginMCPServers() {
+    const map = new Map();
+    for (const p of getEnabledPlugins()) {
+        for (const [name, cfg] of Object.entries(p.mcpServers)) {
+            map.set(`${p.manifest.name}::${name}`, cfg);
+        }
+    }
+    return map;
+}
+// ─── Hooks ────────────────────────────────────────────────────────────
+export async function executeSessionStartHooks() {
+    for (const p of getEnabledPlugins()) {
+        try {
+            await p.hooks?.onSessionStart?.();
+        }
+        catch { /* non-fatal */ }
+    }
+}
+export async function executeSessionEndHooks() {
+    for (const p of getEnabledPlugins()) {
+        try {
+            await p.hooks?.onSessionEnd?.();
+        }
+        catch { /* non-fatal */ }
+    }
+}
+// ─── Discovery and Loading ────────────────────────────────────────────
+/**
+ * Load all installed plugins into the registry.
+ * Called during CrayCode.initialize().
+ */
+export async function loadAllPlugins(projectRoot) {
+    const dirs = getAllPluginSearchDirs(projectRoot);
+    const found = discoverAllPlugins(dirs);
+    const results = [];
+    for (const plugin of found) {
+        // Skip duplicates
+        if (loadedFromPaths.has(plugin.dir))
+            continue;
+        if (plugins.has(plugin.manifest.name))
+            continue;
+        // Load hooks
+        let hooks;
+        const hooksPath = join(plugin.dir, 'hooks.js');
+        if (existsSync(hooksPath)) {
+            try {
+                const hooksUrl = pathToFileURL(hooksPath).href;
+                const mod = await import(hooksUrl);
+                hooks = { ...mod };
+            }
+            catch { /* hooks.js load error */ }
+        }
+        const registered = { ...plugin, hooks };
+        registerPlugin(registered);
+        results.push(registered);
+    }
+    return results;
+}
+/**
+ * Reload all plugins (use after install/remove/enable/disable).
+ */
+export async function reloadAllPlugins(projectRoot) {
+    plugins.clear();
+    loadedFromPaths.clear();
+    await loadAllPlugins(projectRoot);
+}
+// ─── Plugin Management ────────────────────────────────────────────────
+/**
+ * Parse a plugin identifier string.
+ * Supports three formats:
+ *   - Local path:        ./my-plugin  or /absolute/path
+ *   - Marketplace ref:   chrome-devtools-mcp@claude-plugins-official
+ *   - Marketplace slash: claude-plugins-official/chrome-devtools-mcp
+ *
+ * Returns { type: 'local' | 'marketplace', name?, marketplace?, source, refPath? }
+ */
+export function parsePluginRef(source) {
+    // Check for marketplace format: name@marketplace
+    const atMatch = source.match(/^(.+)@(.+)$/);
+    if (atMatch && !source.includes('/') && !source.includes('\\')) {
+        return {
+            type: 'marketplace',
+            name: atMatch[1],
+            marketplace: atMatch[2],
+            displayName: `${atMatch[2]} / ${atMatch[1]}`,
+            localPath: atMatch[1],
+        };
+    }
+    // Check for marketplace format: marketplace/name (with only one slash, no path)
+    const slashMatch = source.match(/^([^@\/\\]+)\/([^@\/\\]+)$/);
+    if (slashMatch) {
+        return {
+            type: 'marketplace',
+            name: slashMatch[2],
+            marketplace: slashMatch[1],
+            displayName: `${slashMatch[1]} / ${slashMatch[2]}`,
+            localPath: slashMatch[2],
+        };
+    }
+    // Treat as local path
+    return {
+        type: 'local',
+        displayName: source,
+        localPath: basename(source),
+    };
+}
+export function installPlugin(source, projectRoot) {
+    const destDir = projectRoot ? getProjectPluginDir(projectRoot) : getUserPluginDir();
+    mkdirSync(destDir, { recursive: true });
+    const ref = parsePluginRef(source);
+    // ─── Local path install ──────────────────────────────────────
+    if (ref.type === 'local') {
+        // Check if it's a URL — git clone and install
+        if (source.startsWith('http://') || source.startsWith('https://')) {
+            return installPluginFromUrl(source, destDir);
+        }
+        const abs = join(process.cwd(), source);
+        // If the name looks like a plugin name (no path separators, no file extension),
+        // and the local directory doesn't exist, treat it as a marketplace plugin.
+        const looksLikePluginName = !source.includes('/') && !source.includes('\\') && !source.includes('.');
+        if (!existsSync(abs) && looksLikePluginName) {
+            // Fall through to marketplace install — resolve against known marketplaces
+            return installFromMarketplace(source, destDir);
+        }
+        if (!existsSync(abs)) {
+            return { success: false, message: `Source not found: ${abs}${looksLikePluginName ? `\n\nDid you mean a marketplace plugin? Try:\n  /plugin install claude-plugins-official/${source}` : ''}` };
+        }
+        if (!statSync(abs).isDirectory()) {
+            return { success: false, message: `Source must be a directory: ${abs}` };
+        }
+        if (!existsSync(join(abs, 'manifest.json'))) {
+            return { success: false, message: `No manifest.json found in ${abs}. Plugins must have a manifest.` };
+        }
+        const name = ref.localPath;
+        const dest = join(destDir, name);
+        if (existsSync(dest)) {
+            return { success: false, message: `Plugin "${name}" is already installed. Remove it first (/plugin remove ${name}).` };
+        }
+        copyDirSync(abs, dest);
+        return { success: true, message: `Plugin "${name}" installed to ${dest}\nReload Cray Code to activate.`, pluginName: name };
+    }
+    // ─── Marketplace install ─────────────────────────────────────
+    const { name, marketplace, displayName } = ref;
+    const pkgName = ref.localPath; // Guaranteed string for marketplace refs
+    const marketplaceId = marketplace ?? '';
+    const skillName = name ?? pkgName;
+    const dest = join(destDir, pkgName);
+    if (existsSync(dest)) {
+        return { success: false, message: `Plugin "${pkgName}" is already installed. Remove it first (/plugin remove ${pkgName}).` };
+    }
+    // Try known marketplaces
+    const resolved = resolveMarketplacePlugin(marketplaceId, skillName);
+    if (resolved) {
+        // Create the plugin with skill stubs
+        mkdirSync(dest, { recursive: true });
+        writeFileSync(join(dest, 'manifest.json'), JSON.stringify({
+            name: skillName,
+            version: '1.0.0',
+            description: `Marketplace plugin: ${displayName}`,
+            author: marketplaceId,
+            repository: resolved,
+        }, null, 2), 'utf-8');
+        writeFileSync(join(dest, 'README.md'), `# ${skillName}\n\nInstalled from ${displayName}.\nSource: ${resolved}`, 'utf-8');
+        // Create basic skill stubs if it's a known plugin type
+        mkdirSync(join(dest, 'commands'), { recursive: true });
+        mkdirSync(join(dest, 'skills'), { recursive: true });
+        mkdirSync(join(dest, 'skills', skillName), { recursive: true });
+        writeFileSync(join(dest, 'skills', skillName, 'SKILL.md'), [
+            '---',
+            `description: "${skillName} — ${displayName}"`,
+            'allowed-tools: [read, glob, grep, bash, web_fetch]',
+            'context: inline',
+            '---',
+            '',
+            `# ${skillName}`,
+            '',
+            'This skill was installed from the marketplace.',
+            '',
+            'To customize: edit this SKILL.md, then reload Cray Code.',
+        ].join('\n'), 'utf-8');
+        return {
+            success: true,
+            message: [
+                `Plugin "${pkgName}" installed from ${displayName}!`,
+                `Directory: ${dest}`,
+                '',
+                `Template files created:`,
+                `  ${dest}/manifest.json`,
+                `  ${dest}/skills/${skillName}/SKILL.md`,
+                '',
+                `Edit the SKILL.md to add your skill instructions,`,
+                `then add commands/*.md files for additional features.`,
+                '',
+                `Reload Cray Code to activate.`,
+            ].join('\n'),
+            pluginName: pkgName,
+        };
+    }
+    // Marketplace not recognized — scaffold an empty plugin for the user
+    mkdirSync(dest, { recursive: true });
+    writeFileSync(join(dest, 'manifest.json'), JSON.stringify({
+        name: skillName,
+        version: '1.0.0',
+        description: `Plugin: ${displayName}`,
+        author: marketplaceId,
+    }, null, 2), 'utf-8');
+    mkdirSync(join(dest, 'commands'), { recursive: true });
+    mkdirSync(join(dest, 'skills'), { recursive: true });
+    mkdirSync(join(dest, 'skills', skillName), { recursive: true });
+    writeFileSync(join(dest, 'skills', skillName, 'SKILL.md'), [
+        '---',
+        `description: "${skillName} skill"`,
+        'allowed-tools: [read, glob, grep]',
+        'context: inline',
+        '---',
+        '',
+        `# ${skillName}`,
+        '',
+        `Marketplace: ${displayName}`,
+        '',
+        '## When to Use',
+        '',
+        'Describe when this skill should be invoked.',
+        '',
+        '## Instructions',
+        '',
+        'Detailed instructions go here.',
+    ].join('\n'), 'utf-8');
+    return {
+        success: true,
+        message: [
+            `Plugin "${pkgName}" scaffolded from ${displayName}.`,
+            `Directory: ${dest}`,
+            '',
+            `Template files created:`,
+            `  ${dest}/manifest.json`,
+            `  ${dest}/skills/${skillName}/SKILL.md`,
+            '',
+            `Edit the SKILL.md and commands/*.md to add your plugin logic.`,
+            `Reload Cray Code to activate: restart cray.`,
+        ].join('\n'),
+        pluginName: pkgName,
+    };
+}
+/**
+ * Install a plugin from a git URL by cloning into the plugins directory.
+ */
+function installPluginFromUrl(gitUrl, destDir) {
+    // Check if git is available
+    try {
+        execFileSync('git', ['--version'], { stdio: 'pipe' });
+    }
+    catch {
+        return { success: false, message: 'Git is required for URL-based plugin installation.\nInstall it from: https://git-scm.com/' };
+    }
+    // Extract a safe directory name from the URL
+    const urlForName = gitUrl.replace(/\.git$/, '').replace(/\/$/, '');
+    const name = basename(urlForName) || 'installed-plugin';
+    const dest = join(destDir, name);
+    if (existsSync(dest)) {
+        return { success: false, message: `Plugin "${name}" already exists. Remove it first: /plugin remove ${name}` };
+    }
+    try {
+        // Clone the repo (shallow to save bandwidth)
+        // Use execFileSync with argument array — no shell, no injection
+        execFileSync('git', ['clone', '--depth', '1', gitUrl, dest], {
+            cwd: destDir,
+            stdio: 'pipe',
+            timeout: 60_000,
+        });
+        // Check for manifest.json
+        if (!existsSync(join(dest, 'manifest.json'))) {
+            // Generate a manifest from repo metadata
+            let desc = `Plugin from ${gitUrl}`;
+            try {
+                const readme = join(dest, 'README.md');
+                if (existsSync(readme)) {
+                    const firstLine = readFileSync(readme, 'utf-8').split('\n')[0];
+                    if (firstLine)
+                        desc = firstLine.replace(/^#+\s*/, '').trim();
+                }
+            }
+            catch { /* use default */ }
+            writeFileSync(join(dest, 'manifest.json'), JSON.stringify({
+                name,
+                version: '1.0.0',
+                description: desc,
+                repository: gitUrl,
+            }, null, 2), 'utf-8');
+        }
+        // If no skills/ directory, create a default one
+        if (!existsSync(join(dest, 'skills'))) {
+            mkdirSync(join(dest, 'skills', name), { recursive: true });
+            writeFileSync(join(dest, 'skills', name, 'SKILL.md'), [
+                '---',
+                `description: "${name} — installed from ${gitUrl}"`,
+                'allowed-tools: [read, glob, grep, bash]',
+                'context: inline',
+                '---',
+                '',
+                `# ${name}`,
+                '',
+                'This plugin was installed from:',
+                `  ${gitUrl}`,
+                '',
+                'Add your skill instructions to this file and reload Cray Code.',
+            ].join('\n'), 'utf-8');
+        }
+        return {
+            success: true,
+            message: [
+                `Plugin "${name}" installed from git!`,
+                `Directory: ${dest}`,
+                '',
+                `Reload Cray Code to activate.`,
+            ].join('\n'),
+            pluginName: name,
+        };
+    }
+    catch (err) {
+        // Clean up failed clone
+        if (existsSync(dest)) {
+            try {
+                rmDirSync(dest);
+            }
+            catch { /* best-effort */ }
+        }
+        const msg = err.stderr ? String(err.stderr) : err.message;
+        return { success: false, message: `Git clone failed: ${msg.slice(0, 300)}` };
+    }
+}
+/**
+ * Resolve a marketplace plugin to a known source URL.
+ * Returns the URL/fetch string, or null if not found.
+ */
+function resolveMarketplacePlugin(marketplace, pluginName) {
+    const key = `${marketplace}/${pluginName}`;
+    const registry = {
+        'claude-plugins-official/chrome-devtools-mcp': 'https://github.com/anthropics/claude-code/tree/main/plugins',
+        'claude-plugins-official/code-review': 'https://github.com/anthropics/claude-code/tree/main/plugins',
+        'claude-plugins-official/mcp-server-context7': 'https://github.com/upstash/context7',
+        'context7/mcp-server-context7': 'https://github.com/upstash/context7',
+        'context7/context7': 'https://github.com/upstash/context7',
+        'claude-plugins-official/gitlab': 'https://gitlab.com',
+        'claude-plugins-official/playwright': 'https://github.com/microsoft/playwright',
+        'claude-plugins-official/linear': 'https://linear.app',
+        'claude-plugins-official/slack': 'https://slack.com',
+        'claude-plugins-official/notion': 'https://notion.so',
+        'claude-plugins-official/figma': 'https://figma.com',
+        'claude-plugins-official/sentry': 'https://sentry.io',
+        'claude-plugins-official/vercel': 'https://vercel.com',
+    };
+    return registry[key] ?? null;
+}
+/**
+ * Try to install a bare plugin name by searching known marketplaces.
+ * When the user types `/plugin install context7`, we search for it.
+ */
+function installFromMarketplace(bareName, destDir) {
+    // Try exact matches first across known marketplaces
+    const knownMarketplaces = [
+        'claude-plugins-official',
+        'context7',
+        'upstash',
+    ];
+    // Exact match: name == known plugin
+    const exactMatches = [];
+    for (const mp of knownMarketplaces) {
+        const resolved = resolveMarketplacePlugin(mp, bareName);
+        if (resolved)
+            exactMatches.push(mp);
+    }
+    // Also check fuzzy matches — if the name contains or is contained by known plugins
+    const allKnownPlugins = [
+        'chrome-devtools-mcp', 'code-review', 'mcp-server-context7', 'context7',
+        'gitlab', 'playwright', 'linear', 'slack', 'notion', 'figma', 'sentry', 'vercel',
+    ];
+    const fuzzyMatches = allKnownPlugins.filter(p => p.toLowerCase().includes(bareName.toLowerCase()) ||
+        bareName.toLowerCase().includes(p.toLowerCase()));
+    // Resolve each fuzzy match
+    const fuzzyResolved = [];
+    for (const pn of fuzzyMatches) {
+        for (const mp of knownMarketplaces) {
+            const resolved = resolveMarketplacePlugin(mp, pn);
+            if (resolved) {
+                fuzzyResolved.push({ name: pn, marketplace: mp });
+                break;
+            }
+        }
+    }
+    // If we found exact matches, install the first one
+    if (exactMatches.length > 0) {
+        const mp = exactMatches[0];
+        return finishMarketplaceInstall(mp, bareName, destDir);
+    }
+    // If we have one fuzzy match, use it
+    if (fuzzyResolved.length === 1) {
+        const match = fuzzyResolved[0];
+        return finishMarketplaceInstall(match.marketplace, match.name, destDir);
+    }
+    // If we have multiple matches, list them
+    if (fuzzyResolved.length > 1) {
+        const suggestions = fuzzyResolved
+            .map(f => `  /plugin install ${f.marketplace}/${f.name}`)
+            .join('\n');
+        return {
+            success: false,
+            message: [
+                `No exact match for "${bareName}". Did you mean one of these?`,
+                '',
+                suggestions,
+                '',
+                `Or install from a specific marketplace: /plugin install <marketplace>/<name>`,
+            ].join('\n'),
+        };
+    }
+    // No match — scaffold a new plugin with the given name
+    const dest = join(destDir, bareName);
+    if (existsSync(dest)) {
+        return { success: false, message: `Plugin "${bareName}" is already installed.` };
+    }
+    mkdirSync(dest, { recursive: true });
+    writeFileSync(join(dest, 'manifest.json'), JSON.stringify({
+        name: bareName,
+        version: '1.0.0',
+        description: `Plugin: ${bareName}`,
+    }, null, 2), 'utf-8');
+    mkdirSync(join(dest, 'commands'), { recursive: true });
+    mkdirSync(join(dest, 'skills'), { recursive: true });
+    mkdirSync(join(dest, 'skills', bareName), { recursive: true });
+    writeFileSync(join(dest, 'skills', bareName, 'SKILL.md'), [
+        '---',
+        `description: "${bareName} skill"`,
+        'allowed-tools: [read, glob, grep]',
+        'context: inline',
+        '---',
+        '',
+        `# ${bareName}`,
+        '',
+        '## When to Use',
+        '',
+        'Describe when this skill should be invoked.',
+        '',
+        '## Instructions',
+        '',
+        'Describe your plugin instructions here.',
+    ].join('\n'), 'utf-8');
+    return {
+        success: true,
+        message: [
+            `Plugin "${bareName}" scaffolded (not found in known marketplaces).`,
+            `Directory: ${dest}`,
+            '',
+            `Template files created:`,
+            `  ${dest}/manifest.json`,
+            `  ${dest}/skills/${bareName}/SKILL.md`,
+            '',
+            `Edit the SKILL.md and commands/*.md to add your plugin logic.`,
+            `Restart cray to activate.`,
+        ].join('\n'),
+        pluginName: bareName,
+    };
+}
+/**
+ * Finish a marketplace install: scaffold the plugin directory with templates.
+ */
+function finishMarketplaceInstall(marketplace, pluginName, destDir) {
+    const dest = join(destDir, pluginName);
+    if (existsSync(dest)) {
+        return { success: false, message: `Plugin "${pluginName}" is already installed. Remove it first (/plugin remove ${pluginName}).` };
+    }
+    const displayName = `${marketplace} / ${pluginName}`;
+    mkdirSync(dest, { recursive: true });
+    writeFileSync(join(dest, 'manifest.json'), JSON.stringify({
+        name: pluginName,
+        version: '1.0.0',
+        description: `Marketplace plugin: ${displayName}`,
+        author: marketplace,
+    }, null, 2), 'utf-8');
+    mkdirSync(join(dest, 'commands'), { recursive: true });
+    mkdirSync(join(dest, 'skills'), { recursive: true });
+    mkdirSync(join(dest, 'skills', pluginName), { recursive: true });
+    writeFileSync(join(dest, 'skills', pluginName, 'SKILL.md'), [
+        '---',
+        `description: "${pluginName} — ${displayName}"`,
+        'allowed-tools: [read, glob, grep, bash, web_fetch]',
+        'context: inline',
+        '---',
+        '',
+        `# ${pluginName}`,
+        '',
+        `This skill was installed from the marketplace (${marketplace}).`,
+        '',
+        'To customize: edit this SKILL.md, then reload Cray Code.',
+    ].join('\n'), 'utf-8');
+    return {
+        success: true,
+        message: [
+            `Plugin "${pluginName}" installed from ${displayName}!`,
+            `Directory: ${dest}`,
+            '',
+            `Template files created:`,
+            `  ${dest}/manifest.json`,
+            `  ${dest}/skills/${pluginName}/SKILL.md`,
+            '',
+            `Edit the SKILL.md to add your plugin's instructions.`,
+            `Restart cray to activate.`,
+        ].join('\n'),
+        pluginName,
+    };
+}
+export function removePlugin(name, projectRoot) {
+    const dirs = getAllPluginSearchDirs(projectRoot);
+    for (const d of dirs) {
+        const target = join(d, name);
+        if (existsSync(target)) {
+            rmDirSync(target);
+            plugins.delete(name);
+            loadedFromPaths.delete(target);
+            return { success: true, message: `Plugin "${name}" removed.` };
+        }
+    }
+    return { success: false, message: `Plugin "${name}" not found in any plugin directory.` };
+}
+export function enablePlugin(name) {
+    const p = plugins.get(name);
+    if (!p)
+        return { success: false, message: `Plugin "${name}" not registered.` };
+    if (p.enabled)
+        return { success: true, message: `Plugin "${name}" is already enabled.` };
+    p.enabled = true;
+    persistPluginState(name, true);
+    return { success: true, message: `Plugin "${name}" enabled. Reload to activate.` };
+}
+export function disablePlugin(name) {
+    const p = plugins.get(name);
+    if (!p)
+        return { success: false, message: `Plugin "${name}" not registered.` };
+    if (!p.enabled)
+        return { success: true, message: `Plugin "${name}" is already disabled.` };
+    p.enabled = false;
+    persistPluginState(name, false);
+    return { success: true, message: `Plugin "${name}" disabled.` };
+}
+// ─── State Persistence ────────────────────────────────────────────────
+function persistPluginState(name, enabled) {
+    try {
+        const statePath = join(homedir(), '.cray', 'plugin_state.json');
+        let state = {};
+        if (existsSync(statePath)) {
+            try {
+                state = JSON.parse(readFileSync(statePath, 'utf-8'));
+            }
+            catch { /* reset */ }
+        }
+        state[name] = enabled;
+        mkdirSync(join(statePath, '..'), { recursive: true });
+        writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf-8');
+    }
+    catch { /* non-fatal */ }
+}
+function loadPluginState() {
+    try {
+        const statePath = join(homedir(), '.cray', 'plugin_state.json');
+        if (existsSync(statePath)) {
+            return JSON.parse(readFileSync(statePath, 'utf-8'));
+        }
+    }
+    catch { /* use defaults */ }
+    return {};
+}
+/**
+ * Apply saved enable/disable state on startup.
+ */
+export function applyPluginState() {
+    const state = loadPluginState();
+    for (const [name, enabled] of Object.entries(state)) {
+        const p = plugins.get(name);
+        if (p)
+            p.enabled = enabled;
+    }
+}
+// ─── File System Helpers ──────────────────────────────────────────────
+function copyDirSync(src, dest) {
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(src)) {
+        const sp = join(src, entry), dp = join(dest, entry);
+        if (statSync(sp).isDirectory()) {
+            copyDirSync(sp, dp);
+        }
+        else {
+            writeFileSync(dp, readFileSync(sp));
+        }
+    }
+}
+function rmDirSync(dir) {
+    if (!existsSync(dir))
+        return;
+    for (const entry of readdirSync(dir)) {
+        const p = join(dir, entry);
+        if (statSync(p).isDirectory()) {
+            rmDirSync(p);
+        }
+        else {
+            unlinkSync(p);
+        }
+    }
+    rmdirSync(dir);
+}
+//# sourceMappingURL=registry.js.map