@prompd/cli 0.3.3

package/dist/lib/registry.js

@@ -0,0 +1,786 @@
+"use strict";
+/**
+ * Prompd Package Registry System (Multi-Registry Architecture)
+ * Core registry infrastructure for publishing and installing packages with scope-based resolution
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultRegistryConfig = exports.RegistryClient = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const semver = __importStar(require("semver"));
+const tar = __importStar(require("tar"));
+const events_1 = require("events");
+const security_1 = require("./security");
+const config_1 = require("./config");
+const file_system_1 = require("./compiler/file-system");
+/**
+ * Package Registry Client
+ */
+class RegistryClient extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.cache = new Map();
+        // Handle legacy string parameter (registry name)
+        const opts = typeof options === 'string'
+            ? { registryName: options }
+            : options || {};
+        const configManager = config_1.ConfigManager.getInstance();
+        // Load config synchronously - this is critical!
+        this.config = this.loadConfigSync(configManager);
+        // Resolve registry name
+        this.registryName = opts.registryName || this.config.registry.default || 'prompdhub';
+        // Get registry config
+        const registries = this.config.registry.registries;
+        if (!registries[this.registryName]) {
+            throw new Error(`Registry '${this.registryName}' not found in configuration`);
+        }
+        this.registryConfig = registries[this.registryName];
+        // Override URL if provided directly (for server-side usage)
+        if (opts.registryUrl) {
+            this.registryConfig = { ...this.registryConfig, url: opts.registryUrl };
+        }
+        this.ensureCacheDir();
+    }
+    get registryUrl() {
+        return this.registryConfig.url;
+    }
+    get authToken() {
+        return this.registryConfig.token;
+    }
+    get cacheDir() {
+        return path.join(require('os').homedir(), '.prompd', 'cache');
+    }
+    get maxPackageSize() {
+        return 50 * 1024 * 1024; // 50MB
+    }
+    /**
+     * Load config synchronously - required for constructor
+     */
+    loadConfigSync(configManager) {
+        // If config is already loaded, use it
+        if (configManager.config) {
+            return configManager.config;
+        }
+        // Otherwise load it synchronously (this is a hack but necessary)
+        const fs = require('fs');
+        const yaml = require('yaml');
+        const os = require('os');
+        const path = require('path');
+        const configPath = path.join(os.homedir(), '.prompd', 'config.yaml');
+        // Use env var for registry URL if set (useful for local development)
+        const registryUrl = process.env.PROMPD_REGISTRY_URL || 'https://registry.prompdhub.ai';
+        const defaultConfig = {
+            apiKeys: {},
+            customProviders: {},
+            registry: {
+                registries: {
+                    prompdhub: {
+                        url: registryUrl
+                    }
+                },
+                default: 'prompdhub'
+            },
+            scopes: {},
+            maxRetries: 3,
+            timeout: 30,
+            verbose: false
+        };
+        try {
+            if (fs.existsSync(configPath)) {
+                const configContent = fs.readFileSync(configPath, 'utf-8');
+                const fileConfig = yaml.parse(configContent);
+                // Merge with default config
+                const mergedConfig = { ...defaultConfig, ...fileConfig };
+                // Ensure registry structure exists
+                if (!mergedConfig.registry) {
+                    mergedConfig.registry = defaultConfig.registry;
+                }
+                if (!mergedConfig.registry.registries) {
+                    mergedConfig.registry.registries = defaultConfig.registry.registries;
+                }
+                if (!mergedConfig.scopes) {
+                    mergedConfig.scopes = {};
+                }
+                return mergedConfig;
+            }
+        }
+        catch (error) {
+            console.warn(`Warning: Error loading config: ${error}`);
+        }
+        return defaultConfig;
+    }
+    /**
+     * Authenticate with registry using token
+     */
+    async loginWithToken(token) {
+        // Verify token by getting user profile
+        const response = await fetch(`${this.registryUrl}/v1/user/me`, {
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (response.status === 401) {
+            throw new Error('Invalid token. Please check your API token.');
+        }
+        else if (response.status === 404) {
+            throw new Error(`User endpoint not found. Registry URL: ${this.registryUrl}`);
+        }
+        else if (response.status >= 500) {
+            throw new Error(`Registry server error (${response.status}). Please try again later.`);
+        }
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Authentication failed: ${errorText}`);
+        }
+        const userData = await response.json();
+        if (!userData.username) {
+            throw new Error('Invalid response from registry: missing username');
+        }
+        // Update registry config
+        const configManager = config_1.ConfigManager.getInstance();
+        await configManager.setRegistryToken(this.registryName, token, userData.username);
+        return { username: userData.username };
+    }
+    /**
+     * Clear authentication credentials
+     */
+    async logout() {
+        const configManager = config_1.ConfigManager.getInstance();
+        await configManager.setRegistryToken(this.registryName, '', '');
+    }
+    /**
+     * Publish a package to the registry
+     */
+    async publish(packagePath, options = {
+        access: 'public',
+        tag: 'latest',
+        dryRun: false,
+        force: false
+    }) {
+        this.emit('publishStart', { packagePath, options });
+        try {
+            // Resolve file system (same pattern as compile)
+            const fileSystem = options.fileSystem || new file_system_1.NodeFileSystem();
+            // Load and validate package metadata from manifest.json
+            const metadata = await this.loadManifestFromFS(packagePath, fileSystem);
+            // Security validation using file system abstraction
+            await this.validatePackageForPublishFS(packagePath, metadata, fileSystem);
+            // Check version conflicts
+            if (!options.force) {
+                const existingVersions = await this.getPackageVersions(metadata.name);
+                if (existingVersions.includes(metadata.version)) {
+                    throw new Error(`Version ${metadata.version} already exists. Use --force to overwrite.`);
+                }
+            }
+            if (options.dryRun) {
+                console.log('Dry run - package would be published:');
+                console.log(JSON.stringify(metadata, null, 2));
+                return;
+            }
+            // Create package tarball Buffer (memory or disk)
+            const tarballBuffer = await this.createPackageTarballBuffer(packagePath, metadata, fileSystem);
+            // Upload to registry
+            await this.uploadPackageBuffer(tarballBuffer, metadata, options);
+            this.emit('publishComplete', {
+                name: metadata.name,
+                version: metadata.version,
+                access: options.access
+            });
+        }
+        catch (error) {
+            this.emit('publishError', { packagePath, error });
+            throw error;
+        }
+    }
+    /**
+     * Install a package from the registry
+     * Accepts both formats:
+     * - @namespace/package (with options.version)
+     * - @namespace/package@version (embedded version)
+     */
+    async install(packageName, options = {}) {
+        this.emit('installStart', { packageName, options });
+        console.log('[RegistryClient.install] Starting install:', packageName);
+        console.log('[RegistryClient.install] Options:', JSON.stringify(options));
+        try {
+            // Parse package reference if it includes @version
+            // Format: @namespace/package@version
+            // Find last @ to split name from version (scoped packages start with @)
+            let name = packageName;
+            let versionSpec = options.version || 'latest';
+            const lastAtIndex = packageName.lastIndexOf('@');
+            if (lastAtIndex > 0) {
+                // Has embedded version: @namespace/package@0.1.5
+                name = packageName.substring(0, lastAtIndex);
+                versionSpec = packageName.substring(lastAtIndex + 1);
+            }
+            console.log('[RegistryClient.install] Parsed name:', name, 'version:', versionSpec);
+            // Resolve version
+            const resolvedVersion = await this.resolveVersion(name, versionSpec);
+            console.log('[RegistryClient.install] Resolved version:', resolvedVersion);
+            // Check cache first
+            const cacheKey = `${name}@${resolvedVersion}`;
+            if (!options.skipCache && !options.force) {
+                const cachedPath = await this.getCachedPackage(cacheKey);
+                if (cachedPath) {
+                    await this.installFromCache(cachedPath, name, resolvedVersion, options);
+                    return;
+                }
+            }
+            // Download package
+            const packageData = await this.downloadPackage(name, resolvedVersion);
+            // Install dependencies (skip self-referential dependencies)
+            const metadata = packageData.metadata;
+            if (metadata.dependencies && Object.keys(metadata.dependencies).length > 0) {
+                // Filter out self-referential dependencies to avoid circular resolution
+                const filteredDeps = {};
+                for (const [depName, depVersion] of Object.entries(metadata.dependencies)) {
+                    if (depName === name) {
+                        // Skip self-referential dependency (package depends on itself)
+                        continue;
+                    }
+                    filteredDeps[depName] = depVersion;
+                }
+                if (Object.keys(filteredDeps).length > 0) {
+                    await this.installDependencies(filteredDeps, options);
+                }
+            }
+            // Extract and install package
+            console.log('[RegistryClient.install] Extracting package to workspace...');
+            await this.extractAndInstallPackage(packageData, name, resolvedVersion, options);
+            console.log('[RegistryClient.install] Extraction complete');
+            // Cache package
+            await this.cachePackage(cacheKey, packageData);
+            this.emit('installComplete', {
+                name: name,
+                version: resolvedVersion
+            });
+            console.log('[RegistryClient.install] Install complete for', name, '@', resolvedVersion);
+        }
+        catch (error) {
+            this.emit('installError', { packageName, error });
+            throw error;
+        }
+    }
+    /**
+     * Search packages in the registry
+     */
+    async search(query) {
+        try {
+            const searchParams = new URLSearchParams();
+            if (query.query)
+                searchParams.set('q', query.query);
+            if (query.category)
+                searchParams.set('category', query.category);
+            if (query.type)
+                searchParams.set('type', query.type);
+            if (query.tags)
+                searchParams.set('tags', query.tags.join(','));
+            if (query.author)
+                searchParams.set('author', query.author);
+            if (query.limit)
+                searchParams.set('limit', query.limit.toString());
+            if (query.offset)
+                searchParams.set('offset', query.offset.toString());
+            if (query.sort)
+                searchParams.set('sort', query.sort);
+            // Registry uses /packages?search= endpoint, not /search?q=
+            const response = await fetch(`${this.registryUrl}/packages?search=${encodeURIComponent(query.query || '')}`, {
+                headers: this.getAuthHeaders()
+            });
+            if (!response.ok) {
+                throw new Error(`Search failed: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            this.emit('searchComplete', { query, results: result.packages.length });
+            return result;
+        }
+        catch (error) {
+            this.emit('searchError', { query, error });
+            throw error;
+        }
+    }
+    /**
+     * Get package information
+     */
+    async getPackageInfo(packageName, version) {
+        try {
+            const url = version
+                ? `${this.registryUrl}/packages/${packageName}/${version}`
+                : `${this.registryUrl}/packages/${packageName}`;
+            const response = await fetch(url, {
+                headers: this.getAuthHeaders()
+            });
+            if (!response.ok) {
+                if (response.status === 404) {
+                    throw new Error(`Package not found: ${packageName}`);
+                }
+                throw new Error(`Failed to get package info: ${response.status} ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            this.emit('packageInfoError', { packageName, version, error });
+            throw error;
+        }
+    }
+    /**
+     * Get available versions for a package
+     */
+    async getPackageVersions(packageName) {
+        try {
+            const response = await fetch(`${this.registryUrl}/packages/${packageName}/versions`, {
+                headers: this.getAuthHeaders()
+            });
+            if (!response.ok) {
+                if (response.status === 404) {
+                    return [];
+                }
+                throw new Error(`Failed to get package versions: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            // Handle both response formats (like Python CLI does):
+            // 1. Direct array: [{version: "1.0.0", ...}, ...]
+            // 2. Wrapped object: {versions: [...]}
+            let versionsList;
+            if (Array.isArray(data)) {
+                versionsList = data;
+            }
+            else if (data.versions && Array.isArray(data.versions)) {
+                versionsList = data.versions;
+            }
+            else {
+                throw new Error('Invalid versions response format');
+            }
+            // Extract version strings from version objects
+            return versionsList.map(v => typeof v === 'string' ? v : v.version);
+        }
+        catch (error) {
+            this.emit('packageVersionsError', { packageName, error });
+            throw error;
+        }
+    }
+    async loadPackageMetadata(packageDir) {
+        const projectFile = path.join(packageDir, 'project.prmdproj');
+        if (!await fs.pathExists(projectFile)) {
+            throw new Error('No project.prmdproj file found');
+        }
+        const content = await fs.readFile(projectFile, 'utf8');
+        const yaml = require('yaml');
+        // Parse YAML frontmatter
+        const match = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!match) {
+            throw new Error('Invalid project.prmdproj file format');
+        }
+        const metadata = yaml.parse(match[1]);
+        // Validate required fields
+        const required = ['name', 'version', 'description', 'author'];
+        for (const field of required) {
+            if (!metadata[field]) {
+                throw new Error(`Missing required field: ${field}`);
+            }
+        }
+        // Validate version format
+        if (!semver.valid(metadata.version)) {
+            throw new Error(`Invalid version format: ${metadata.version}`);
+        }
+        // Set defaults
+        metadata.license = metadata.license || 'MIT';
+        metadata.keywords = metadata.keywords || [];
+        metadata.dependencies = metadata.dependencies || {};
+        metadata.files = metadata.files || ['**/*'];
+        metadata.type = metadata.type || 'collection';
+        metadata.category = metadata.category || 'general';
+        metadata.tags = metadata.tags || [];
+        metadata.prmdVersion = '0.2.3';
+        metadata.createdAt = new Date().toISOString();
+        metadata.updatedAt = new Date().toISOString();
+        return metadata;
+    }
+    async validatePackageForPublish(packageDir, metadata) {
+        // Check package size
+        const stats = await this.getDirectorySize(packageDir);
+        if (stats.size > this.maxPackageSize) {
+            throw new Error(`Package size (${stats.size}) exceeds maximum allowed (${this.maxPackageSize})`);
+        }
+        // Validate package name
+        const sanitizedName = security_1.SecurityManager.sanitizeToolName(metadata.name);
+        if (sanitizedName !== metadata.name) {
+            throw new Error(`Invalid package name: ${metadata.name}`);
+        }
+        // Check for required files
+        const requiredFiles = [];
+        if (metadata.type === 'prompt' && metadata.main) {
+            requiredFiles.push(metadata.main);
+        }
+        for (const file of requiredFiles) {
+            const filePath = path.join(packageDir, file);
+            if (!await fs.pathExists(filePath)) {
+                throw new Error(`Required file not found: ${file}`);
+            }
+        }
+        // Validate dependencies
+        for (const [depName, depVersion] of Object.entries(metadata.dependencies)) {
+            if (!semver.validRange(depVersion)) {
+                throw new Error(`Invalid dependency version range: ${depName}@${depVersion}`);
+            }
+        }
+    }
+    async createPackageTarball(packageDir, metadata) {
+        const tarballName = `${metadata.name}-${metadata.version}.tgz`;
+        const tarballPath = path.join(this.cacheDir, 'temp', tarballName);
+        await fs.ensureDir(path.dirname(tarballPath));
+        // Create tarball with only specified files
+        await tar.create({
+            gzip: true,
+            file: tarballPath,
+            cwd: packageDir,
+            prefix: 'package/',
+            filter: (path) => {
+                // Include files matching patterns in metadata.files
+                return this.matchesFilePatterns(path, metadata.files);
+            }
+        }, ['.']);
+        return tarballPath;
+    }
+    async uploadPackage(tarballPath, metadata, options) {
+        const formData = new FormData();
+        const tarballBuffer = await fs.readFile(tarballPath);
+        formData.append('package', new Blob([tarballBuffer]), `${metadata.name}-${metadata.version}.tgz`);
+        formData.append('metadata', JSON.stringify(metadata));
+        formData.append('access', options.access);
+        formData.append('tag', options.tag);
+        const response = await fetch(`${this.registryUrl}/publish`, {
+            method: 'POST',
+            headers: this.getAuthHeaders(),
+            body: formData
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Publish failed: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+    }
+    async resolveVersion(packageName, versionSpec) {
+        if (versionSpec === 'latest') {
+            const packageInfo = await this.getPackageInfo(packageName);
+            return packageInfo.version;
+        }
+        if (semver.valid(versionSpec)) {
+            return versionSpec;
+        }
+        // Resolve version range
+        const versions = await this.getPackageVersions(packageName);
+        const resolved = semver.maxSatisfying(versions, versionSpec);
+        if (!resolved) {
+            throw new Error(`No version found matching: ${versionSpec}`);
+        }
+        return resolved;
+    }
+    /**
+     * Download a package without installing it to disk.
+     * Useful for in-memory package loading.
+     *
+     * @param packageName - Package name (e.g., "@namespace/package-name")
+     * @param version - Package version (e.g., "1.0.0")
+     * @returns Object with tarball Buffer and package metadata
+     */
+    async downloadPackageBuffer(packageName, version) {
+        return this.downloadPackage(packageName, version);
+    }
+    async downloadPackage(packageName, version) {
+        // Registry endpoint format: /packages/@scope/name/download/version
+        const response = await fetch(`${this.registryUrl}/packages/${packageName}/download/${version}`, {
+            headers: this.getAuthHeaders()
+        });
+        if (!response.ok) {
+            throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const tarballBuffer = Buffer.from(arrayBuffer);
+        // Extract metadata from the .pdpkg (ZIP) file instead of calling getPackageInfo
+        // Try prompd.json first, fall back to manifest.json for older packages
+        const AdmZip = (await Promise.resolve().then(() => __importStar(require('adm-zip')))).default;
+        const zip = new AdmZip(tarballBuffer);
+        // Check for prompd.json first (newer format), then manifest.json (legacy)
+        let manifestEntry = zip.getEntry('prompd.json');
+        if (!manifestEntry) {
+            manifestEntry = zip.getEntry('manifest.json');
+        }
+        if (!manifestEntry) {
+            throw new Error(`Invalid package: neither prompd.json nor manifest.json found in ${packageName}@${version}`);
+        }
+        const manifestContent = manifestEntry.getData().toString('utf8');
+        const metadata = JSON.parse(manifestContent);
+        return {
+            tarball: tarballBuffer,
+            metadata
+        };
+    }
+    async installDependencies(dependencies, options) {
+        for (const [name, versionSpec] of Object.entries(dependencies)) {
+            this.emit('installingDependency', { name, version: versionSpec });
+            await this.install(name, { ...options, version: versionSpec });
+        }
+    }
+    async extractAndInstallPackage(packageData, packageName, version, options) {
+        // Use workspace root from options if provided, otherwise use cwd
+        const workspaceRoot = options.workspaceRoot || process.cwd();
+        console.log('[RegistryClient.extractAndInstallPackage] packageName:', packageName);
+        console.log('[RegistryClient.extractAndInstallPackage] version:', version);
+        console.log('[RegistryClient.extractAndInstallPackage] workspaceRoot:', workspaceRoot);
+        console.log('[RegistryClient.extractAndInstallPackage] global:', options.global);
+        const installDir = options.global
+            ? path.join(this.cacheDir, 'global', 'packages', packageName, version)
+            : path.join(workspaceRoot, '.prompd', 'cache', packageName, version);
+        console.log('[RegistryClient.extractAndInstallPackage] installDir:', installDir);
+        await fs.ensureDir(installDir);
+        console.log('[RegistryClient.extractAndInstallPackage] Directory ensured');
+        // Extract .pdpkg (ZIP archive) using adm-zip
+        const AdmZip = (await Promise.resolve().then(() => __importStar(require('adm-zip')))).default;
+        const zip = new AdmZip(packageData.tarball);
+        // Log zip contents
+        const zipEntries = zip.getEntries();
+        console.log('[RegistryClient.extractAndInstallPackage] ZIP contains', zipEntries.length, 'entries:');
+        zipEntries.forEach(entry => {
+            console.log('  -', entry.entryName);
+        });
+        zip.extractAllTo(installDir, true);
+        console.log('[RegistryClient.extractAndInstallPackage] ZIP extracted to:', installDir);
+        // Verify extraction
+        const extractedFiles = await fs.readdir(installDir);
+        console.log('[RegistryClient.extractAndInstallPackage] Extracted files:', extractedFiles);
+        // Write package metadata for cache tracking
+        const metadataPath = path.join(installDir, '.prmdmeta');
+        await fs.writeJson(metadataPath, packageData.metadata, { spaces: 2 });
+        console.log('[RegistryClient.extractAndInstallPackage] Wrote .prmdmeta');
+    }
+    getAuthHeaders() {
+        const headers = {
+            'User-Agent': 'prompd-cli/0.2.4',
+            'Content-Type': 'application/json'
+        };
+        if (this.authToken) {
+            headers['Authorization'] = `Bearer ${this.authToken}`;
+        }
+        return headers;
+    }
+    async ensureCacheDir() {
+        await fs.ensureDir(this.cacheDir);
+        await fs.ensureDir(path.join(this.cacheDir, 'temp'));
+    }
+    async getDirectorySize(dir) {
+        let totalSize = 0;
+        let totalFiles = 0;
+        const items = await fs.readdir(dir);
+        for (const item of items) {
+            const fullPath = path.join(dir, item);
+            const stats = await fs.stat(fullPath);
+            if (stats.isDirectory()) {
+                const subStats = await this.getDirectorySize(fullPath);
+                totalSize += subStats.size;
+                totalFiles += subStats.files;
+            }
+            else {
+                totalSize += stats.size;
+                totalFiles++;
+            }
+        }
+        return { size: totalSize, files: totalFiles };
+    }
+    matchesFilePatterns(filePath, patterns) {
+        // Simple glob matching - in production would use proper glob library
+        for (const pattern of patterns) {
+            if (pattern === '**/*' || pattern === '*') {
+                return true;
+            }
+            if (pattern.includes('*')) {
+                const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+                if (regex.test(filePath)) {
+                    return true;
+                }
+            }
+            else if (filePath === pattern) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async getCachedPackage(cacheKey) {
+        const cachePath = path.join(this.cacheDir, 'packages', cacheKey);
+        return await fs.pathExists(cachePath) ? cachePath : null;
+    }
+    async installFromCache(cachePath, packageName, version, options) {
+        console.log('[RegistryClient.installFromCache] Installing from cache:', cachePath);
+        this.emit('installingFromCache', { name: packageName, version });
+        // Read the cached tarball
+        const tarballBuffer = await fs.readFile(cachePath);
+        console.log('[RegistryClient.installFromCache] Read tarball:', tarballBuffer.length, 'bytes');
+        // Extract to the workspace
+        const packageData = { tarball: tarballBuffer, metadata: { name: packageName, version } };
+        await this.extractAndInstallPackage(packageData, packageName, version, options);
+        console.log('[RegistryClient.installFromCache] Extraction complete');
+    }
+    async cachePackage(cacheKey, packageData) {
+        const cachePath = path.join(this.cacheDir, 'packages', cacheKey);
+        await fs.ensureDir(path.dirname(cachePath));
+        await fs.writeFile(cachePath, packageData.tarball);
+    }
+    /**
+     * Load manifest.json from file system abstraction.
+     * Supports both disk-based and in-memory file systems.
+     */
+    async loadManifestFromFS(packagePath, fileSystem) {
+        const manifestPath = fileSystem.join(packagePath, 'manifest.json');
+        const exists = await Promise.resolve(fileSystem.exists(manifestPath));
+        if (!exists) {
+            throw new Error('No manifest.json file found');
+        }
+        const content = await Promise.resolve(fileSystem.readFile(manifestPath));
+        const manifest = JSON.parse(content);
+        // Validate required fields
+        const required = ['name', 'version', 'description', 'author'];
+        for (const field of required) {
+            if (!manifest[field]) {
+                throw new Error(`Missing required field in manifest.json: ${field}`);
+            }
+        }
+        // Validate version format
+        if (!semver.valid(manifest.version)) {
+            throw new Error(`Invalid version format: ${manifest.version}`);
+        }
+        // Set defaults
+        manifest.license = manifest.license || 'MIT';
+        manifest.keywords = manifest.keywords || [];
+        manifest.dependencies = manifest.dependencies || {};
+        manifest.files = manifest.files || ['**/*.prmd'];
+        manifest.type = manifest.type || 'collection';
+        manifest.category = manifest.category || 'general';
+        manifest.tags = manifest.tags || [];
+        manifest.prompdVersion = manifest.prompdVersion || '0.3.3';
+        manifest.createdAt = manifest.createdAt || new Date().toISOString();
+        manifest.updatedAt = new Date().toISOString();
+        return manifest;
+    }
+    /**
+     * Validate package for publish using file system abstraction.
+     */
+    async validatePackageForPublishFS(packagePath, metadata, fileSystem) {
+        // Calculate package size
+        const stats = fileSystem instanceof file_system_1.MemoryFileSystem
+            ? fileSystem.getTotalSize(packagePath)
+            : await this.getDirectorySize(packagePath);
+        if (stats.size > this.maxPackageSize) {
+            throw new Error(`Package size (${stats.size}) exceeds maximum allowed (${this.maxPackageSize})`);
+        }
+        // Validate package name (use existing security manager)
+        const sanitizedName = security_1.SecurityManager.sanitizeToolName(metadata.name);
+        if (sanitizedName !== metadata.name) {
+            throw new Error(`Invalid package name: ${metadata.name}`);
+        }
+        // Validate dependencies
+        for (const [depName, depVersion] of Object.entries(metadata.dependencies)) {
+            if (!semver.validRange(depVersion)) {
+                throw new Error(`Invalid dependency version range: ${depName}@${depVersion}`);
+            }
+        }
+    }
+    /**
+     * Create package tarball Buffer using file system abstraction.
+     * Supports both in-memory and disk-based package creation.
+     */
+    async createPackageTarballBuffer(packagePath, metadata, fileSystem) {
+        // Memory-based path
+        if (fileSystem instanceof file_system_1.MemoryFileSystem) {
+            return await fileSystem.createPackageBuffer(packagePath, metadata, {
+                filter: (filePath) => this.matchesFilePatterns(filePath, metadata.files)
+            });
+        }
+        // Disk-based path (existing logic)
+        const tarballName = `${metadata.name}-${metadata.version}.tgz`;
+        const tarballPath = path.join(this.cacheDir, 'temp', tarballName);
+        await fs.ensureDir(path.dirname(tarballPath));
+        await tar.create({
+            gzip: true,
+            file: tarballPath,
+            cwd: packagePath,
+            prefix: 'package/',
+            filter: (filePath) => this.matchesFilePatterns(filePath, metadata.files)
+        }, ['.']);
+        const buffer = await fs.readFile(tarballPath);
+        await fs.remove(tarballPath); // Cleanup
+        return buffer;
+    }
+    /**
+     * Upload package Buffer to registry.
+     */
+    async uploadPackageBuffer(tarballBuffer, metadata, options) {
+        const FormData = require('form-data');
+        const formData = new FormData();
+        formData.append('package', tarballBuffer, {
+            filename: `${metadata.name}-${metadata.version}.pdpkg`,
+            contentType: 'application/gzip'
+        });
+        formData.append('metadata', JSON.stringify(metadata));
+        formData.append('access', options.access);
+        formData.append('tag', options.tag);
+        const response = await fetch(`${this.registryUrl}/publish`, {
+            method: 'POST',
+            headers: {
+                ...this.getAuthHeaders(),
+                ...formData.getHeaders()
+            },
+            body: formData
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Publish failed: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+    }
+}
+exports.RegistryClient = RegistryClient;
+/**
+ * Default registry configuration
+ */
+const createDefaultRegistryConfig = () => ({
+    registryUrl: process.env.PROMPD_REGISTRY_URL || 'https://registry.prompdhub.ai',
+    authToken: process.env.PROMPD_AUTH_TOKEN,
+    cacheDir: path.join(require('os').homedir(), '.prmd', 'cache'),
+    timeout: 30000,
+    maxPackageSize: 50 * 1024 * 1024 // 50MB
+});
+exports.createDefaultRegistryConfig = createDefaultRegistryConfig;
+//# sourceMappingURL=registry.js.map