openpets 1.0.8 → 1.0.10

package/dist/src/core/cli.js

@@ -2,21 +2,30 @@
 import { buildPet } from './build-pet.js';
 import { deployPet } from './deploy-pet.js';
 import { addFolderToHistory } from './config-manager.js';
+import { getRegistryClient } from './registry-client.js';
+import { loadPetConfig, validatePetConfig, generateOpenpetsYamlTemplate } from './pet-config.js';
+import { getPackageDiscovery, getRegistryAggregator } from './discovery.js';
+import { getPetDownloader } from './pet-downloader.js';
+import { getAllPets } from './search-pets.js';
+import { syncEnvToConfig } from '../sdk/plugin-factory.js';
 import { spawn } from 'child_process';
-import { resolve } from 'path';
-import { readFileSync, existsSync } from 'fs';
+import { resolve, join } from 'path';
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs';
+import * as readline from 'readline';
 async function publishPet(petName, options = {}) {
     const { preview = false, channel = 'latest' } = options;
     // Find the script path - try multiple locations
-    let scriptPath = resolve(__dirname, '../../scripts/publish-pet.ts');
-    if (!existsSync(scriptPath)) {
-        // We might be in a different location, try relative to cwd
-        scriptPath = resolve(process.cwd(), '../../scripts/publish-pet.ts');
-    }
-    if (!existsSync(scriptPath)) {
-        console.error(`❌ Publish script not found: ${scriptPath}`);
-        console.error(`   Tried: ${resolve(__dirname, '../../scripts/publish-pet.ts')}`);
-        console.error(`   And: ${resolve(process.cwd(), '../../scripts/publish-pet.ts')}`);
+    const possiblePaths = [
+        resolve(__dirname, '../../scripts/publish-pet.ts'),
+        resolve(__dirname, '../../../scripts/publish-pet.ts'),
+        resolve(process.cwd(), 'scripts/publish-pet.ts'),
+        resolve(process.cwd(), '../../scripts/publish-pet.ts')
+    ];
+    let scriptPath = possiblePaths.find(p => existsSync(p));
+    if (!scriptPath) {
+        console.error(`❌ Publish script not found`);
+        console.error(`   Tried:`);
+        possiblePaths.forEach(p => console.error(`     - ${p}`));
         process.exit(1);
     }
     // If no petName provided, try to infer from current directory
@@ -121,6 +130,14 @@ function launchManager() {
     const uiDir = resolve(__dirname, '../../apps/desktop');
     const projectDir = process.cwd();
     addFolderToHistory(projectDir);
+    // Sync .env to .pets/config.json before launching
+    // This ensures .pets/config.json is the single source of truth for env vars
+    console.log('Syncing environment configuration...');
+    const syncResult = syncEnvToConfig(projectDir);
+    if (syncResult.success && syncResult.synced > 0) {
+        console.log(`✅ Synced ${syncResult.synced} env vars to .pets/config.json`);
+    }
+    log('Env sync result:', syncResult);
     console.log('Launching OpenPets Plugin Manager...');
     console.log(`Project directory: ${projectDir}`);
     console.log(`UI directory: ${uiDir}`);
@@ -143,8 +160,8 @@ function launchManager() {
         process.exit(1);
     }
     killPort(1420);
-    log('Spawning npm process with tauri:dev');
-    const child = spawn('npm', ['run', 'tauri:dev'], {
+    log('Spawning bun process with tauri:dev');
+    const child = spawn('bun', ['run', 'tauri:dev'], {
         cwd: uiDir,
         stdio: 'inherit',
         shell: true,
@@ -210,35 +227,1142 @@ else if (command === 'publish') {
         process.exit(1);
     });
 }
+else if (command === 'install') {
+    handleInstall(args.slice(1));
+}
+else if (command === 'add') {
+    handleAdd(args.slice(1));
+}
+else if (command === 'uninstall' || command === 'remove' || command === 'delete') {
+    handleUninstall(args.slice(1));
+}
+else if (command === 'inspect') {
+    handleInspect(args.slice(1));
+}
+else if (command === 'search') {
+    handleSearch(args.slice(1));
+}
+else if (command === 'list') {
+    handleList(args.slice(1));
+}
+else if (command === 'run') {
+    handleRun(args.slice(1));
+}
+else if (command === 'init') {
+    handleInit(args.slice(1));
+}
+else if (command === 'validate') {
+    handleValidate(args.slice(1));
+}
+else if (command === 'playground') {
+    handlePlayground();
+}
+else if (command === 'discover') {
+    handleDiscover(args.slice(1));
+}
+else if (command === 'registry') {
+    handleRegistry(args.slice(1));
+}
+else if (command === 'prune') {
+    handlePrune(args.slice(1));
+}
+else if (command === 'reload') {
+    handleReload(args.slice(1));
+}
+else if (command === 'help' || command === '--help' || command === '-h') {
+    showHelp();
+}
 else if (!command) {
     log('No command provided, launching manager UI');
     launchManager();
 }
 else {
     log('Unknown command:', command);
-    console.error('Usage: pets [command] [options]');
-    console.error('');
-    console.error('Commands:');
-    console.error('  (none)                Launch the plugin manager UI (default)');
-    console.error('  build <pet-name>      Build and validate a pet package');
-    console.error('  deploy <pet-name>     Build and deploy a pet package with metadata');
-    console.error('  publish [pet-name]    Publish a pet package to npm (auto-detects if in pet dir)');
-    console.error('');
-    console.error('Publish Options:');
-    console.error('  --preview             Dry-run mode (no actual publish)');
-    console.error('  --channel <name>      Publish to a specific npm tag (default: latest)');
-    console.error('');
-    console.error('Examples:');
-    console.error('  pets                  # Launch the desktop plugin manager');
-    console.error('  pets build postgres');
-    console.error('  pets deploy maps');
-    console.error('  pets publish maps                    # From root directory');
-    console.error('  cd pets/maps && pets publish         # From pet directory');
-    console.error('  pets publish --preview               # Dry-run from pet directory');
-    console.error('  pets publish maps --channel beta');
-    console.error('');
-    console.error('Environment:');
-    console.error('  PETS_DEBUG=true       Enable detailed debug logging');
+    showUnknownCommandError(command);
     process.exit(1);
 }
+async function handleInstall(args) {
+    const packageName = args.find(a => !a.startsWith('--'));
+    if (!packageName) {
+        console.error('❌ Package name required');
+        console.error('Usage: pets install <package-name> --client <client>');
+        process.exit(1);
+    }
+    const clientIndex = args.indexOf('--client');
+    const client = (clientIndex >= 0 ? args[clientIndex + 1] : 'opencode');
+    const configIndex = args.indexOf('--config');
+    const configStr = configIndex >= 0 ? args[configIndex + 1] : undefined;
+    const config = configStr ? JSON.parse(configStr) : undefined;
+    const global = args.includes('--global') || args.includes('-g');
+    const versionIndex = args.indexOf('--version');
+    const version = versionIndex >= 0 ? args[versionIndex + 1] : undefined;
+    console.log(`📦 Installing ${packageName}...`);
+    log('Install options:', { client, config, global, version });
+    const registry = getRegistryClient();
+    const result = await registry.install(packageName, { client, config, global, version });
+    if (result.success) {
+        console.log(`✅ ${result.message}`);
+        if (result.path) {
+            console.log(`   📁 Installed to: ${result.path}`);
+        }
+        console.log(`\n💡 Remember to restart your AI client to apply changes.`);
+    }
+    else {
+        console.error(`❌ ${result.message}`);
+        process.exit(1);
+    }
+}
+async function handleUninstall(args) {
+    const packageName = args.find(a => !a.startsWith('--'));
+    if (!packageName) {
+        console.error('❌ Package name required');
+        console.error('Usage: pets uninstall <package-name> --client <client>');
+        process.exit(1);
+    }
+    const clientIndex = args.indexOf('--client');
+    const client = (clientIndex >= 0 ? args[clientIndex + 1] : 'opencode');
+    const global = args.includes('--global') || args.includes('-g');
+    console.log(`🗑️  Uninstalling ${packageName}...`);
+    const registry = getRegistryClient();
+    const result = await registry.uninstall(packageName, { client, global });
+    if (result.success) {
+        console.log(`✅ ${result.message}`);
+        console.log(`\n💡 Remember to restart your AI client to apply changes.`);
+    }
+    else {
+        console.error(`❌ ${result.message}`);
+        process.exit(1);
+    }
+}
+async function handleInspect(args) {
+    const packageName = args.find(a => !a.startsWith('--'));
+    if (!packageName) {
+        console.error('❌ Package name required');
+        console.error('Usage: pets inspect <package-name>');
+        process.exit(1);
+    }
+    console.log(`🔍 Inspecting ${packageName}...`);
+    const registry = getRegistryClient();
+    const { package: pkg, installed, versions } = await registry.inspect(packageName);
+    if (!pkg) {
+        console.error(`❌ Package not found: ${packageName}`);
+        process.exit(1);
+    }
+    console.log('');
+    console.log(`📦 ${pkg.name}`);
+    console.log(`   Version: ${pkg.version}`);
+    console.log(`   Description: ${pkg.description || 'No description'}`);
+    if (pkg.keywords && pkg.keywords.length > 0) {
+        console.log(`   Keywords: ${pkg.keywords.join(', ')}`);
+    }
+    if (pkg.homepage) {
+        console.log(`   Homepage: ${pkg.homepage}`);
+    }
+    if (pkg.repository) {
+        const repoUrl = typeof pkg.repository === 'string' ? pkg.repository : pkg.repository.url;
+        console.log(`   Repository: ${repoUrl}`);
+    }
+    if (pkg.author) {
+        const authorStr = typeof pkg.author === 'string' ? pkg.author : pkg.author.name;
+        console.log(`   Author: ${authorStr}`);
+    }
+    console.log('');
+    if (installed) {
+        console.log(`✅ Installed locally`);
+        console.log(`   Version: ${installed.version}`);
+        console.log(`   Path: ${installed.path}`);
+        console.log(`   Installed: ${new Date(installed.installedAt).toLocaleString()}`);
+    }
+    else {
+        console.log(`❌ Not installed locally`);
+    }
+    if (versions.length > 0) {
+        console.log('');
+        console.log(`📋 Available versions: ${versions.slice(0, 5).join(', ')}${versions.length > 5 ? '...' : ''}`);
+    }
+}
+async function handleSearch(args) {
+    const query = args.filter(a => !a.startsWith('--')).join(' ');
+    const limitIndex = args.indexOf('--limit');
+    const limit = limitIndex >= 0 ? parseInt(args[limitIndex + 1], 10) : 20;
+    console.log(query ? `🔍 Searching for "${query}"...` : '🔍 Listing all @openpets packages...');
+    const registry = getRegistryClient();
+    const results = await registry.search(query, limit);
+    if (results.objects.length === 0) {
+        console.log('No packages found.');
+        return;
+    }
+    console.log(`\nFound ${results.total} packages:\n`);
+    for (const { package: pkg, score } of results.objects) {
+        const shortName = pkg.name.replace('@openpets/', '');
+        console.log(`  📦 ${shortName}`);
+        console.log(`     ${pkg.description || 'No description'}`);
+        console.log(`     v${pkg.version} | Score: ${(score.final * 100).toFixed(0)}%`);
+        console.log('');
+    }
+    console.log(`💡 Use "pets install <name>" to install a package`);
+    console.log(`💡 Use "pets inspect <name>" to see more details`);
+}
+async function handleList(args) {
+    const listType = args[0] || 'installed';
+    const registry = getRegistryClient();
+    if (listType === 'clients') {
+        console.log('📋 Supported clients:\n');
+        const clients = registry.listClients();
+        for (const client of clients) {
+            const configPath = registry.getClientConfigPath(client);
+            const exists = configPath && existsSync(configPath);
+            console.log(`  ${exists ? '✅' : '❌'} ${client}`);
+            if (configPath && configPath !== 'custom') {
+                console.log(`     ${configPath}`);
+            }
+        }
+        return;
+    }
+    if (listType === 'servers' || listType === 'installed') {
+        const clientIndex = args.indexOf('--client');
+        const client = (clientIndex >= 0 ? args[clientIndex + 1] : undefined);
+        console.log('📋 Installed pets:\n');
+        const opencodeJsonPath = resolve(process.cwd(), 'opencode.json');
+        const petsConfigPath = resolve(process.cwd(), '.pets', 'config.json');
+        let localPlugins = [];
+        let disabledPets = [];
+        if (existsSync(opencodeJsonPath)) {
+            try {
+                const config = JSON.parse(readFileSync(opencodeJsonPath, 'utf-8'));
+                if (config.plugin) {
+                    localPlugins = Array.isArray(config.plugin) ? config.plugin : [config.plugin];
+                }
+            }
+            catch (e) {
+                log('Error reading opencode.json:', e);
+            }
+        }
+        if (existsSync(petsConfigPath)) {
+            try {
+                const petsConfig = JSON.parse(readFileSync(petsConfigPath, 'utf-8'));
+                if (petsConfig.disabled && Array.isArray(petsConfig.disabled)) {
+                    disabledPets = petsConfig.disabled;
+                }
+            }
+            catch (e) {
+                log('Error reading .pets/config.json:', e);
+            }
+        }
+        let remoteApiData = null;
+        const openpetsPlugins = localPlugins.filter(p => p.startsWith('@openpets/'));
+        const allPetsToLookup = [...openpetsPlugins, ...disabledPets.map(p => `@openpets/${p}`)];
+        if (allPetsToLookup.length > 0) {
+            try {
+                const allPets = await getAllPets();
+                remoteApiData = new Map();
+                for (const pet of allPets) {
+                    remoteApiData.set(pet.id, pet);
+                    remoteApiData.set(`@openpets/${pet.id}`, pet);
+                }
+            }
+            catch (e) {
+                log('Failed to fetch remote API data:', e);
+            }
+        }
+        if (localPlugins.length > 0) {
+            console.log('  📁 Local plugins (from opencode.json):\n');
+            for (const plugin of localPlugins) {
+                const isOpenpetsPackage = plugin.startsWith('@openpets/');
+                if (isOpenpetsPackage) {
+                    const shortName = plugin.replace('@openpets/', '');
+                    const remotePet = remoteApiData?.get(shortName) || remoteApiData?.get(plugin);
+                    if (remotePet) {
+                        console.log(`  ✅ ${remotePet.displayName || remotePet.name}`);
+                        if (remotePet.description) {
+                            console.log(`     ${remotePet.description}`);
+                        }
+                        if (remotePet.version) {
+                            console.log(`     v${remotePet.version}`);
+                        }
+                        if (remotePet.tools && remotePet.tools.length > 0) {
+                            console.log(`     🔧 ${remotePet.tools.length} tools`);
+                        }
+                        console.log(`     📦 ${plugin}`);
+                    }
+                    else {
+                        console.log(`  ❓ ${plugin}`);
+                        console.log(`     (not found in registry)`);
+                    }
+                    console.log('');
+                    continue;
+                }
+                const pluginPath = resolve(process.cwd(), plugin);
+                const exists = existsSync(pluginPath) || existsSync(pluginPath.replace('.ts', ''));
+                const status = exists ? '✅' : '❌';
+                let pkgInfo = { name: plugin, description: '', version: '' };
+                const pluginDir = pluginPath.replace(/\/index\.ts$/, '').replace(/\.ts$/, '');
+                const pkgJsonPath = join(pluginDir, 'package.json');
+                if (existsSync(pkgJsonPath)) {
+                    try {
+                        const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+                        pkgInfo = {
+                            name: pkg.title || pkg.name || plugin,
+                            description: pkg.subtitle || pkg.description || '',
+                            version: pkg.version || ''
+                        };
+                    }
+                    catch (e) { }
+                }
+                console.log(`  ${status} ${pkgInfo.name}`);
+                if (pkgInfo.description) {
+                    console.log(`     ${pkgInfo.description}`);
+                }
+                if (pkgInfo.version) {
+                    console.log(`     v${pkgInfo.version}`);
+                }
+                console.log(`     📁 ${plugin}`);
+                console.log('');
+            }
+        }
+        if (disabledPets.length > 0) {
+            console.log('  🚫 Disabled pets (from .pets/config.json):\n');
+            for (const pet of disabledPets) {
+                const remotePet = remoteApiData?.get(pet) || remoteApiData?.get(`@openpets/${pet}`);
+                if (remotePet) {
+                    console.log(`  ❌ ${remotePet.displayName || remotePet.name}`);
+                    if (remotePet.description) {
+                        console.log(`     ${remotePet.description}`);
+                    }
+                    console.log(`     📦 @openpets/${pet}`);
+                }
+                else {
+                    console.log(`  ❌ ${pet}`);
+                }
+                console.log('');
+            }
+        }
+        const installed = registry.getInstalledPets();
+        if (installed.length > 0) {
+            console.log('  📦 Registry-installed pets:\n');
+            for (const pet of installed) {
+                const shortName = pet.name.replace('@openpets/', '');
+                console.log(`  📦 ${shortName}`);
+                console.log(`     Version: ${pet.version}`);
+                console.log(`     Installed: ${new Date(pet.installedAt).toLocaleDateString()}`);
+                console.log('');
+            }
+        }
+        if (localPlugins.length === 0 && installed.length === 0 && disabledPets.length === 0) {
+            console.log('  No pets installed yet.');
+            console.log('  Use "pets search" to find packages');
+            console.log('  Use "pets install <name>" to install');
+        }
+        return;
+    }
+    console.error(`Unknown list type: ${listType}`);
+    console.log('Usage: pets list [clients|servers|installed]');
+}
+async function handleRun(args) {
+    const packageName = args.find(a => !a.startsWith('--'));
+    if (!packageName) {
+        console.error('❌ Package name required');
+        console.error('Usage: pets run <package-name> [--config \'{"key":"value"}\']');
+        process.exit(1);
+    }
+    const configIndex = args.indexOf('--config');
+    const configStr = configIndex >= 0 ? args[configIndex + 1] : undefined;
+    const config = configStr ? JSON.parse(configStr) : undefined;
+    const transportIndex = args.indexOf('--transport');
+    const transport = (transportIndex >= 0 ? args[transportIndex + 1] : 'stdio');
+    console.log(`🚀 Running ${packageName}...`);
+    const registry = getRegistryClient();
+    await registry.run(packageName, { config, transport });
+}
+async function handleInit(args) {
+    const name = args.find(a => !a.startsWith('--'));
+    const targetDir = args.includes('--dir')
+        ? args[args.indexOf('--dir') + 1]
+        : process.cwd();
+    const format = args.includes('--yaml') ? 'yaml' : 'json';
+    const runtimeIndex = args.indexOf('--runtime');
+    const runtime = (runtimeIndex >= 0 ? args[runtimeIndex + 1] : 'typescript');
+    const petName = name || resolve(targetDir).split('/').pop() || 'my-pet';
+    console.log(`🐾 Initializing new pet: ${petName}`);
+    if (format === 'yaml') {
+        const yamlContent = generateOpenpetsYamlTemplate({
+            name: petName,
+            runtime
+        });
+        const yamlPath = join(targetDir, 'openpets.yaml');
+        writeFileSync(yamlPath, yamlContent);
+        console.log(`✅ Created openpets.yaml`);
+    }
+    else {
+        const config = {
+            $schema: 'https://pets.studio/config.json',
+            name: `@openpets/${petName}`,
+            version: '1.0.0',
+            title: petName.charAt(0).toUpperCase() + petName.slice(1),
+            subtitle: `${petName} plugin`,
+            description: `${petName} plugin for OpenPets`,
+            categories: ['general'],
+            keywords: ['openpets', 'plugin', petName],
+            main: 'index.ts',
+            types: 'index.ts',
+            envVariables: {},
+            queries: ['example query'],
+            scenarios: {
+                'basic-test': ['example query']
+            },
+            scripts: {
+                build: 'pets build',
+                test: 'pets validate'
+            },
+            dependencies: {
+                openpets: 'workspace:*'
+            }
+        };
+        const jsonPath = join(targetDir, 'package.json');
+        writeFileSync(jsonPath, JSON.stringify(config, null, 2));
+        console.log(`✅ Created package.json`);
+    }
+    const opencodeConfig = {
+        $schema: 'https://opencode.ai/config.json',
+        plugin: ['./index.ts']
+    };
+    const opencodePath = join(targetDir, 'opencode.json');
+    writeFileSync(opencodePath, JSON.stringify(opencodeConfig, null, 2));
+    console.log(`✅ Created opencode.json`);
+    const indexPath = join(targetDir, 'index.ts');
+    if (!existsSync(indexPath)) {
+        const indexContent = `import { createPlugin } from 'openpets'
+
+export default createPlugin({
+  name: '${petName}',
+  description: '${petName} plugin',
+  tools: [
+    {
+      name: '${petName}-hello',
+      description: 'Say hello from ${petName}',
+      schema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Name to greet' }
+        }
+      },
+      execute: async ({ name = 'World' }) => {
+        return { message: \`Hello, \${name}! From ${petName}.\` }
+      }
+    }
+  ]
+})
+`;
+        writeFileSync(indexPath, indexContent);
+        console.log(`✅ Created index.ts`);
+    }
+    console.log(`
+🎉 Pet initialized! Next steps:
+
+  1. Edit index.ts to add your tools
+  2. Run "pets validate" to check your configuration
+  3. Run "pets build" to build your pet
+  4. Run "pets publish" to publish to npm
+`);
+}
+async function handleValidate(args) {
+    const targetDir = args.find(a => !a.startsWith('--')) || process.cwd();
+    console.log(`🔍 Validating pet configuration in ${targetDir}...`);
+    const config = loadPetConfig(targetDir);
+    if (!config) {
+        console.error('❌ Could not load configuration');
+        process.exit(1);
+    }
+    const result = validatePetConfig(config);
+    if (result.valid) {
+        console.log('✅ Configuration is valid');
+    }
+    else {
+        console.log('❌ Configuration has errors:');
+        result.errors.forEach(err => console.log(`   ❌ ${err}`));
+    }
+    if (result.warnings.length > 0) {
+        console.log('\n⚠️  Warnings:');
+        result.warnings.forEach(warn => console.log(`   ⚠️  ${warn}`));
+    }
+    console.log(`\n📦 Pet: ${config.name}`);
+    console.log(`   Version: ${config.version}`);
+    console.log(`   Description: ${config.description}`);
+    if (!result.valid) {
+        process.exit(1);
+    }
+}
+function handlePlayground() {
+    console.log('🎮 Opening OpenPets Playground...');
+    const playgroundUrl = 'https://pets.studio/playground';
+    const openCommand = process.platform === 'darwin' ? 'open' :
+        process.platform === 'win32' ? 'start' : 'xdg-open';
+    spawn(openCommand, [playgroundUrl], { stdio: 'ignore', detached: true }).unref();
+    console.log(`\n📌 Playground URL: ${playgroundUrl}`);
+}
+async function handleDiscover(args) {
+    const includeGithub = args.includes('--github');
+    const npmOnly = args.includes('--npm-only');
+    const limitIndex = args.indexOf('--limit');
+    const limit = limitIndex >= 0 ? parseInt(args[limitIndex + 1], 10) : 50;
+    const githubToken = process.env.GITHUB_TOKEN;
+    console.log('🔍 Discovering OpenPets-compatible packages...\n');
+    if (includeGithub && !githubToken) {
+        console.log('⚠️  GitHub discovery requires GITHUB_TOKEN environment variable');
+        console.log('   Set it to search for packages with $schema field in package.json\n');
+    }
+    const discovery = getPackageDiscovery();
+    try {
+        const packages = await discovery.discoverAll({
+            includeNpm: true,
+            includeGithub: includeGithub && !!githubToken,
+            githubToken,
+            limit
+        });
+        if (packages.length === 0) {
+            console.log('No packages found.');
+            return;
+        }
+        console.log(`Found ${packages.length} compatible packages:\n`);
+        const npmPackages = packages.filter(p => p.source === 'npm');
+        const githubPackages = packages.filter(p => p.source === 'github');
+        if (npmPackages.length > 0) {
+            console.log('📦 From npm registry:');
+            console.log('─'.repeat(50));
+            for (const pkg of npmPackages.slice(0, 20)) {
+                const shortName = pkg.name.replace('@openpets/', '');
+                const score = pkg.score ? ` (score: ${(pkg.score * 100).toFixed(0)}%)` : '';
+                console.log(`  ${shortName}${score}`);
+                console.log(`    ${pkg.description || 'No description'}`);
+                console.log(`    v${pkg.version}`);
+                console.log('');
+            }
+            if (npmPackages.length > 20) {
+                console.log(`  ... and ${npmPackages.length - 20} more\n`);
+            }
+        }
+        if (githubPackages.length > 0) {
+            console.log('🐙 From GitHub repositories:');
+            console.log('─'.repeat(50));
+            for (const pkg of githubPackages.slice(0, 10)) {
+                const stars = pkg.stars ? ` ⭐ ${pkg.stars}` : '';
+                console.log(`  ${pkg.name}${stars}`);
+                console.log(`    ${pkg.description || 'No description'}`);
+                if (pkg.repository) {
+                    console.log(`    ${pkg.repository}`);
+                }
+                console.log('');
+            }
+            if (githubPackages.length > 10) {
+                console.log(`  ... and ${githubPackages.length - 10} more\n`);
+            }
+        }
+        console.log('─'.repeat(50));
+        console.log(`\n💡 Discovery methods used:`);
+        console.log(`   • npm: Search @openpets/* scope and "openpets" keyword`);
+        if (includeGithub && githubToken) {
+            console.log(`   • GitHub: Search for $schema field pointing to pets.studio`);
+        }
+        console.log(`\n💡 To include GitHub results: pets discover --github`);
+        console.log(`   (requires GITHUB_TOKEN environment variable)`);
+    }
+    catch (error) {
+        console.error(`❌ Discovery failed: ${error.message}`);
+        process.exit(1);
+    }
+}
+async function handleRegistry(args) {
+    const subcommand = args[0] || 'status';
+    const aggregator = getRegistryAggregator();
+    if (subcommand === 'update' || subcommand === 'refresh') {
+        console.log('🔄 Updating package registry...');
+        const githubToken = process.env.GITHUB_TOKEN;
+        await aggregator.updateRegistry({
+            includeNpm: true,
+            includeGithub: !!githubToken,
+            githubToken
+        });
+        const packages = await aggregator.getRegistry();
+        console.log(`✅ Registry updated: ${packages.length} packages indexed`);
+        return;
+    }
+    if (subcommand === 'export') {
+        const outputPath = args[1] || 'registry.json';
+        const json = await aggregator.exportRegistry();
+        writeFileSync(outputPath, json);
+        console.log(`✅ Registry exported to ${outputPath}`);
+        return;
+    }
+    if (subcommand === 'import') {
+        const inputPath = args[1];
+        if (!inputPath || !existsSync(inputPath)) {
+            console.error('❌ Input file required');
+            console.error('Usage: pets registry import <file.json>');
+            process.exit(1);
+        }
+        const json = readFileSync(inputPath, 'utf-8');
+        await aggregator.importRegistry(json);
+        console.log(`✅ Registry imported from ${inputPath}`);
+        return;
+    }
+    if (subcommand === 'status') {
+        const packages = await aggregator.getRegistry();
+        console.log('📊 Registry Status\n');
+        console.log(`Total packages: ${packages.length}`);
+        const npmCount = packages.filter(p => p.source === 'npm').length;
+        const githubCount = packages.filter(p => p.source === 'github').length;
+        console.log(`  • npm packages: ${npmCount}`);
+        console.log(`  • GitHub packages: ${githubCount}`);
+        const withSchema = packages.filter(p => p.schemaVersion).length;
+        console.log(`  • With $schema field: ${withSchema}`);
+        console.log(`\n💡 Run "pets registry update" to refresh the registry`);
+        return;
+    }
+    console.error(`Unknown registry subcommand: ${subcommand}`);
+    console.log('Usage: pets registry [status|update|export|import]');
+}
+function ensureOpencodeJson(targetDir = process.cwd()) {
+    const opencodeJsonPath = resolve(targetDir, 'opencode.json');
+    const opencodeJsoncPath = resolve(targetDir, 'opencode.jsonc');
+    if (existsSync(opencodeJsonPath)) {
+        return opencodeJsonPath;
+    }
+    if (existsSync(opencodeJsoncPath)) {
+        return opencodeJsoncPath;
+    }
+    const defaultConfig = {
+        "$schema": "https://opencode.ai/config.json",
+        "plugin": []
+    };
+    writeFileSync(opencodeJsonPath, JSON.stringify(defaultConfig, null, 2));
+    console.log('✅ Created opencode.json');
+    return opencodeJsonPath;
+}
+async function handleAdd(args) {
+    const packageName = args.find(a => !a.startsWith('--'));
+    if (!packageName) {
+        console.error('❌ Package name required');
+        console.error('Usage: pets add <package-name> [--skip-config] [--version <version>]');
+        process.exit(1);
+    }
+    const skipConfig = args.includes('--skip-config');
+    const versionIndex = args.indexOf('--version');
+    const version = versionIndex >= 0 ? args[versionIndex + 1] : undefined;
+    const configIndex = args.indexOf('--config');
+    const configStr = configIndex >= 0 ? args[configIndex + 1] : undefined;
+    const presetEnv = configStr ? JSON.parse(configStr) : undefined;
+    ensureOpencodeJson();
+    console.log(`\n📦 Adding ${packageName}...`);
+    const downloader = getPetDownloader();
+    const result = await downloader.add(packageName, {
+        targetDir: process.cwd(),
+        version,
+        skipConfig,
+        envValues: presetEnv
+    });
+    if (!result.success) {
+        console.error(`\n❌ ${result.message}`);
+        process.exit(1);
+    }
+    console.log(`\n✅ ${result.message}`);
+    if (result.packagePath) {
+        console.log(`   📁 Downloaded to: ${result.packagePath}`);
+    }
+    if (result.config) {
+        console.log(`   📋 ${result.config.title || result.config.name}`);
+        if (result.config.description) {
+            console.log(`   ${result.config.description}`);
+        }
+    }
+    if (result.envVariables && result.envVariables.length > 0 && !skipConfig) {
+        console.log('\n🔧 Configuration required:\n');
+        await promptForConfiguration(result.envVariables, result.packagePath);
+    }
+    else if (result.envVariables && result.envVariables.length > 0) {
+        console.log('\n⚠️  Environment variables needed (skipped with --skip-config):');
+        for (const env of result.envVariables) {
+            const status = env.currentValue ? '✅' : (env.required ? '❌' : '⚪');
+            console.log(`   ${status} ${env.name}: ${env.description}`);
+        }
+    }
+    console.log('\n💡 Plugin added to opencode.json');
+    console.log('   To apply changes:');
+    console.log('   • New session: restart opencode');
+    console.log('   • Keep session: run "opencode --continue" or "pets reload"\n');
+}
+async function promptForConfiguration(envVariables, packagePath) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const prompt = (question) => {
+        return new Promise((resolve) => {
+            rl.question(question, (answer) => {
+                resolve(answer);
+            });
+        });
+    };
+    const envValues = {};
+    const requiredVars = envVariables.filter(v => v.required);
+    const optionalVars = envVariables.filter(v => !v.required);
+    if (requiredVars.length > 0) {
+        console.log('Required environment variables:\n');
+        for (const env of requiredVars) {
+            const currentValue = env.currentValue ? ` [current: ${env.secret ? '***' : env.currentValue}]` : '';
+            const providerInfo = env.provider ? ` (${env.provider})` : '';
+            console.log(`  ${env.name}${providerInfo}`);
+            console.log(`  ${env.description}`);
+            const value = await prompt(`  Enter value${currentValue}: `);
+            if (value.trim()) {
+                envValues[env.name] = value.trim();
+            }
+            console.log('');
+        }
+    }
+    if (optionalVars.length > 0) {
+        const configureOptional = await prompt('Configure optional variables? (y/N): ');
+        if (configureOptional.toLowerCase() === 'y') {
+            console.log('\nOptional environment variables:\n');
+            for (const env of optionalVars) {
+                const currentValue = env.currentValue ? ` [current: ${env.secret ? '***' : env.currentValue}]` : '';
+                const providerInfo = env.provider ? ` (${env.provider})` : '';
+                console.log(`  ${env.name}${providerInfo}`);
+                console.log(`  ${env.description}`);
+                const value = await prompt(`  Enter value${currentValue} (press Enter to skip): `);
+                if (value.trim()) {
+                    envValues[env.name] = value.trim();
+                }
+                console.log('');
+            }
+        }
+    }
+    rl.close();
+    if (Object.keys(envValues).length > 0) {
+        // Extract petId from the package path (e.g., /path/to/@openpets/maps -> maps)
+        const petId = packagePath.split('/').pop() || 'unknown';
+        // Save to .pets/config.json (proper location for pet environment variables)
+        const petsConfigDir = resolve(process.cwd(), '.pets');
+        const petsConfigPath = resolve(petsConfigDir, 'config.json');
+        try {
+            // Ensure .pets directory exists
+            if (!existsSync(petsConfigDir)) {
+                mkdirSync(petsConfigDir, { recursive: true });
+            }
+            // Load existing config or create new one
+            let petsConfig = {
+                enabled: [],
+                disabled: [],
+                envConfig: {},
+            };
+            if (existsSync(petsConfigPath)) {
+                try {
+                    const existing = JSON.parse(readFileSync(petsConfigPath, 'utf-8'));
+                    petsConfig = {
+                        enabled: existing.enabled || [],
+                        disabled: existing.disabled || [],
+                        envConfig: existing.envConfig || {},
+                        ...existing
+                    };
+                }
+                catch (e) {
+                    log('Could not parse existing .pets/config.json, creating new structure');
+                }
+            }
+            // Ensure envConfig structure exists
+            if (!petsConfig.envConfig) {
+                petsConfig.envConfig = {};
+            }
+            // Create or update pet-specific env config
+            if (!petsConfig.envConfig[petId]) {
+                petsConfig.envConfig[petId] = {};
+            }
+            // Set the environment variables
+            Object.assign(petsConfig.envConfig[petId], envValues);
+            // Update timestamp
+            petsConfig.last_updated = new Date().toISOString();
+            // Write config
+            writeFileSync(petsConfigPath, JSON.stringify(petsConfig, null, 2));
+            console.log('✅ Configuration saved to .pets/config.json');
+        }
+        catch (error) {
+            console.error(`⚠️  Could not save configuration to .pets/config.json: ${error.message}`);
+            console.log('\nAdd these to your .env file or .pets/config.json manually:');
+            for (const [key, value] of Object.entries(envValues)) {
+                console.log(`  ${key}=${value}`);
+            }
+        }
+    }
+}
+async function launchConfigModal(packageName, envVariables) {
+    const uiDir = resolve(__dirname, '../../apps/desktop');
+    if (!existsSync(uiDir)) {
+        console.log('Desktop UI not available, using CLI configuration...');
+        await promptForConfiguration(envVariables, '');
+        return;
+    }
+    console.log('🖥️  Launching configuration modal...');
+    const configData = {
+        packageName,
+        envVariables,
+        projectDir: process.cwd()
+    };
+    const child = spawn('bun', ['run', 'tauri:dev'], {
+        cwd: uiDir,
+        stdio: 'inherit',
+        shell: true,
+        env: {
+            ...process.env,
+            OPENPETS_CONFIG_MODE: 'true',
+            OPENPETS_CONFIG_DATA: JSON.stringify(configData),
+            OPENPETS_PROJECT_DIR: process.cwd()
+        }
+    });
+    child.on('error', (error) => {
+        console.error('Failed to launch configuration modal:', error);
+        console.log('Falling back to CLI configuration...');
+        promptForConfiguration(envVariables, '');
+    });
+}
+async function handlePrune(args) {
+    const keepPets = args.filter(a => !a.startsWith('--'));
+    const dryRun = args.includes('--dry-run');
+    if (keepPets.length === 0) {
+        console.error('❌ At least one pet name required');
+        console.error('Usage: pets prune <pet-name> [pet-name2...] [--dry-run]');
+        console.error('\nExamples:');
+        console.error('  pets prune maps              # Keep only maps, disable all others');
+        console.error('  pets prune maps github       # Keep maps and github, disable all others');
+        console.error('  pets prune maps --dry-run    # Preview changes without applying');
+        process.exit(1);
+    }
+    const opencodeJsonPath = ensureOpencodeJson();
+    const petsConfigDir = resolve(process.cwd(), '.pets');
+    const petsConfigPath = resolve(petsConfigDir, 'config.json');
+    console.log(`\n🔍 Pruning plugins to keep only: ${keepPets.join(', ')}`);
+    if (dryRun) {
+        console.log('   (dry-run mode - no changes will be made)\n');
+    }
+    else {
+        console.log('');
+    }
+    const opencodeConfig = JSON.parse(readFileSync(opencodeJsonPath, 'utf-8'));
+    const currentPlugins = Array.isArray(opencodeConfig.plugin)
+        ? opencodeConfig.plugin
+        : (opencodeConfig.plugin ? [opencodeConfig.plugin] : []);
+    const normalizeId = (id) => {
+        return id
+            .replace(/^@openpets\//, '')
+            .replace(/^openpets\//, '')
+            .replace(/^pets\//, '')
+            .replace(/^\.\/pets\//, '')
+            .replace(/\/index\.ts$/, '')
+            .replace(/\/index\.js$/, '');
+    };
+    const keepNormalized = new Set(keepPets.map(normalizeId));
+    const petsToVerify = keepPets.map(normalizeId);
+    const toKeep = [];
+    const toDisable = [];
+    for (const plugin of currentPlugins) {
+        const normalized = normalizeId(plugin);
+        if (!keepNormalized.has(normalized)) {
+            toDisable.push(plugin);
+        }
+    }
+    if (dryRun) {
+        console.log('📦 Plugins to VERIFY and KEEP (will check registry):');
+        for (const pet of petsToVerify) {
+            console.log(`   ✅ @openpets/${pet}`);
+        }
+        console.log('\n🚫 Plugins to DISABLE:');
+        if (toDisable.length === 0) {
+            console.log('   (none)');
+        }
+        else {
+            for (const plugin of toDisable) {
+                console.log(`   ❌ ${plugin}`);
+            }
+        }
+        console.log('\n💡 Run without --dry-run to apply these changes');
+        return;
+    }
+    console.log('📦 Verifying plugins from registry...\n');
+    const downloader = getPetDownloader();
+    for (const petName of petsToVerify) {
+        console.log(`   📦 ${petName}...`);
+        const result = await downloader.add(petName, {
+            targetDir: process.cwd(),
+            skipConfig: true
+        });
+        if (!result.success) {
+            console.error(`\n❌ ${result.message}`);
+            console.error(`\n⚠️  Prune aborted - fix the above error and try again`);
+            process.exit(1);
+        }
+        console.log(`   ✅ ${result.message}`);
+        if (result.packagePath) {
+            console.log(`      📁 ${result.packagePath}`);
+        }
+    }
+    console.log('');
+    const updatedConfig = JSON.parse(readFileSync(opencodeJsonPath, 'utf-8'));
+    const updatedPlugins = Array.isArray(updatedConfig.plugin)
+        ? updatedConfig.plugin
+        : (updatedConfig.plugin ? [updatedConfig.plugin] : []);
+    for (const plugin of updatedPlugins) {
+        const normalized = normalizeId(plugin);
+        if (keepNormalized.has(normalized)) {
+            toKeep.push(plugin);
+        }
+    }
+    console.log('📦 Plugins KEPT enabled:');
+    for (const plugin of toKeep) {
+        console.log(`   ✅ ${plugin}`);
+    }
+    console.log('\n🚫 Plugins to DISABLE:');
+    if (toDisable.length === 0) {
+        console.log('   (none)');
+    }
+    else {
+        for (const plugin of toDisable) {
+            console.log(`   ❌ ${plugin}`);
+        }
+    }
+    const finalConfig = JSON.parse(readFileSync(opencodeJsonPath, 'utf-8'));
+    finalConfig.plugin = toKeep;
+    writeFileSync(opencodeJsonPath, JSON.stringify(finalConfig, null, 2));
+    console.log('\n✅ Updated opencode.json');
+    let petsConfig = {
+        enabled: [],
+        disabled: [],
+    };
+    if (existsSync(petsConfigPath)) {
+        try {
+            petsConfig = JSON.parse(readFileSync(petsConfigPath, 'utf-8'));
+        }
+        catch (e) {
+            log('Could not parse existing .pets/config.json, creating new one');
+        }
+    }
+    if (!Array.isArray(petsConfig.enabled))
+        petsConfig.enabled = [];
+    if (!Array.isArray(petsConfig.disabled))
+        petsConfig.disabled = [];
+    for (const plugin of toKeep) {
+        const normalized = normalizeId(plugin);
+        petsConfig.disabled = petsConfig.disabled.filter(p => normalizeId(p) !== normalized);
+        if (!petsConfig.enabled.some(p => normalizeId(p) === normalized)) {
+            petsConfig.enabled.push(normalized);
+        }
+    }
+    for (const plugin of toDisable) {
+        const normalized = normalizeId(plugin);
+        petsConfig.enabled = petsConfig.enabled.filter(p => normalizeId(p) !== normalized);
+        if (!petsConfig.disabled.some(p => normalizeId(p) === normalized)) {
+            petsConfig.disabled.push(normalized);
+        }
+    }
+    petsConfig.last_updated = new Date().toISOString();
+    if (!existsSync(petsConfigDir)) {
+        mkdirSync(petsConfigDir, { recursive: true });
+    }
+    writeFileSync(petsConfigPath, JSON.stringify(petsConfig, null, 2));
+    console.log('✅ Updated .pets/config.json');
+    console.log(`\n🎉 Pruned ${toDisable.length} plugin(s), kept ${toKeep.length} plugin(s)`);
+    console.log('💡 To apply changes:');
+    console.log('   • New session: restart opencode');
+    console.log('   • Keep session: run "opencode --continue" or "pets reload"');
+}
+async function handleReload(args) {
+    const sessionIndex = args.indexOf('--session');
+    const sessionId = sessionIndex >= 0 ? args[sessionIndex + 1] : undefined;
+    const message = args.filter(a => !a.startsWith('--') && a !== sessionId).join(' ') || undefined;
+    console.log('🔄 Reloading OpenCode session with updated plugins...\n');
+    const opencodeJsonPath = resolve(process.cwd(), 'opencode.json');
+    const opencodeJsoncPath = resolve(process.cwd(), 'opencode.jsonc');
+    if (!existsSync(opencodeJsonPath) && !existsSync(opencodeJsoncPath)) {
+        console.error('❌ No opencode.json found in current directory');
+        console.error('   Run this command from a directory with an opencode.json file');
+        process.exit(1);
+    }
+    const configPath = existsSync(opencodeJsonPath) ? opencodeJsonPath : opencodeJsoncPath;
+    try {
+        const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+        const plugins = Array.isArray(config.plugin) ? config.plugin : (config.plugin ? [config.plugin] : []);
+        if (plugins.length > 0) {
+            console.log(`📦 Plugins to load: ${plugins.length}`);
+            for (const p of plugins.slice(0, 5)) {
+                const shortName = typeof p === 'string' ? p.replace('@openpets/', '').replace('./pets/', '') : p;
+                console.log(`   • ${shortName}`);
+            }
+            if (plugins.length > 5) {
+                console.log(`   ... and ${plugins.length - 5} more`);
+            }
+            console.log('');
+        }
+    }
+    catch (e) {
+        log('Could not read opencode.json:', e);
+    }
+    const opencodeArgs = ['--continue'];
+    if (sessionId) {
+        opencodeArgs.push('--session', sessionId);
+    }
+    if (message) {
+        console.log(`💬 Starting with message: "${message}"\n`);
+        const child = spawn('opencode', ['run', message, ...opencodeArgs], {
+            stdio: 'inherit',
+            shell: true,
+            cwd: process.cwd()
+        });
+        child.on('error', (error) => {
+            console.error('❌ Failed to start opencode:', error.message);
+            process.exit(1);
+        });
+        child.on('exit', (code) => {
+            process.exit(code || 0);
+        });
+    }
+    else {
+        console.log('🚀 Launching OpenCode TUI...\n');
+        const child = spawn('opencode', opencodeArgs, {
+            stdio: 'inherit',
+            shell: true,
+            cwd: process.cwd()
+        });
+        child.on('error', (error) => {
+            console.error('❌ Failed to start opencode:', error.message);
+            process.exit(1);
+        });
+        child.on('exit', (code) => {
+            process.exit(code || 0);
+        });
+    }
+}
+function showUnknownCommandError(command) {
+    const validCommands = [
+        'add', 'install', 'uninstall', 'remove', 'delete', 'inspect', 'search', 'list', 'run', 'prune', 'reload',
+        'init', 'build', 'deploy', 'validate', 'publish', 'playground',
+        'discover', 'registry', 'help'
+    ];
+    const similar = validCommands.find(cmd => cmd.startsWith(command.slice(0, 2)) ||
+        command.startsWith(cmd.slice(0, 2)));
+    console.error(`❌ Unknown command: "${command}"`);
+    if (similar) {
+        console.error(`   Did you mean: pets ${similar}?`);
+    }
+    console.error(`\nRun "pets help" for available commands.`);
+}
+function showHelp() {
+    console.log(`
+🐾 OpenPets CLI - Plugin Registry & Management Tool
+
+USAGE:
+  pets <command> [options]
+
+REGISTRY COMMANDS:
+  add <name>              Download pet and add to local opencode.json
+    --version <version>   Install specific version
+    --skip-config         Skip environment variable configuration
+    --config '{"k":"v"}'  Pre-set environment variables
+
+  install <name>          Install a pet from the registry (npm install)
+    --client <client>     Target client (claude, opencode, cursor, vscode)
+    --config '{"k":"v"}'  Pre-configure environment variables
+    --global, -g          Install globally
+    --version <version>   Install specific version
+
+  uninstall <name>        Uninstall a pet (aliases: remove, delete)
+    --client <client>     Target client to remove from
+    --global, -g          Uninstall globally
+
+  inspect <name>          Show detailed package information
+  search [query]          Search for pets in the registry
+    --limit <n>           Limit results (default: 20)
+
+  list [type]             List resources
+    clients               Show supported AI clients
+    servers               Show installed pets for a client
+    installed             Show all installed pets (default)
+    --client <client>     Filter by client
+
+  run <name>              Run a pet locally
+    --config '{"k":"v"}'  Configuration to pass
+    --transport <type>    Transport type (stdio, http)
+
+  prune <pet> [pets...]   Keep only specified pets, disable all others
+    --dry-run             Preview changes without applying
+
+  reload [message]        Reload OpenCode with updated plugins (continues session)
+    --session <id>        Continue a specific session instead of the last one
+
+DEVELOPMENT COMMANDS:
+  init [name]             Initialize a new pet project
+    --yaml                Create openpets.yaml instead of package.json
+    --runtime <type>      Runtime type (typescript, bun, container)
+    --dir <path>          Target directory
+
+  build <pet-name>        Build and validate a pet package
+  deploy <pet-name>       Build and deploy with metadata
+  validate [dir]          Validate pet configuration
+
+  publish [pet-name]      Publish a pet to npm
+    --preview             Dry-run mode
+    --channel <name>      npm tag (default: latest)
+
+  playground              Open the web playground
+
+DISCOVERY COMMANDS:
+  discover                Find OpenPets-compatible packages
+    --github              Include GitHub repository search
+    --limit <n>           Maximum results (default: 50)
+
+  registry [subcommand]   Manage the package registry
+    status                Show registry statistics (default)
+    update                Refresh the registry from sources
+    export [file]         Export registry to JSON file
+    import <file>         Import registry from JSON file
+
+OTHER:
+  (no command)            Launch the desktop plugin manager
+  help, --help, -h        Show this help message
+
+EXAMPLES:
+  pets add maps                                  # Download @openpets/maps and configure
+  pets add @openpets/maps --skip-config          # Download without configuration prompts
+  pets add postgres --config '{"DATABASE_URL":"postgres://..."}'
+  pets install maps --client claude              # Install via npm for specific client
+  pets search github
+  pets inspect linear
+  pets list clients
+  pets list servers --client opencode
+  pets run hackernews
+  pets init my-awesome-pet
+  pets validate ./pets/my-pet
+  pets publish --preview
+  pets discover --github
+  pets registry update
+  pets prune maps                               # Keep only maps, disable all others
+  pets prune maps github --dry-run              # Preview pruning to maps and github
+  pets reload                                   # Reload OpenCode with updated plugins
+  pets reload "test notion"                     # Reload and send a message
+
+ENVIRONMENT:
+  PETS_DEBUG=true         Enable detailed debug logging
+  GITHUB_TOKEN=<token>    GitHub token for repository discovery
+
+HOW DISCOVERY WORKS:
+  The discovery system finds OpenPets-compatible packages via:
+
+  1. npm Registry: Searches @openpets/* scope and "openpets" keyword
+  2. GitHub (optional): Searches for package.json files containing
+     "$schema": "https://pets.studio/config.json"
+
+  To make your package discoverable:
+  - Publish to npm under @openpets/* scope, OR
+  - Add "openpets" to your package.json keywords, OR
+  - Add "$schema": "https://pets.studio/config.json" to package.json
+
+Learn more: https://pets.studio/docs
+`);
+}
 //# sourceMappingURL=cli.js.map