openpets 1.0.5 → 1.0.6

package/build-pet.ts

@@ -1,429 +0,0 @@
-import { join, dirname } from 'path'
-import { fileURLToPath } from 'url'
-import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from 'fs'
-import { pathToFileURL } from 'url'
-import { PluginValidator } from './validate-pet.js'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const projectRoot = dirname(dirname(__dirname))
-
-const DEBUG = process.env.PETS_DEBUG === 'true'
-
-function debug(...msgs: any[]) {
-  if (DEBUG) {
-    console.log('[BUILD-PET]', ...msgs)
-  }
-}
-
-interface ToolDefinition {
-  name: string
-  description: string
-  schema: any
-}
-
-async function extractToolsFromIndexFile(indexPath: string): Promise<ToolDefinition[]> {
-  debug('=== EXTRACTING TOOLS FROM INDEX FILE ===')
-  debug('Index path:', indexPath)
-  debug('File exists:', existsSync(indexPath))
-
-  try {
-    const indexUrl = pathToFileURL(indexPath).href
-    debug('Index URL:', indexUrl)
-
-    debug('Attempting dynamic import...')
-    const indexModule = await import(/* @vite-ignore */ indexUrl)
-    debug('Import successful')
-    debug('Module keys:', Object.keys(indexModule))
-
-    if (indexModule.toolsMetadata && Array.isArray(indexModule.toolsMetadata)) {
-      console.log(`   Found ${indexModule.toolsMetadata.length} tools from exported toolsMetadata`)
-      debug('Tools metadata:', JSON.stringify(indexModule.toolsMetadata, null, 2))
-      return indexModule.toolsMetadata
-    } else {
-      debug('toolsMetadata not found or not an array')
-      debug('indexModule.toolsMetadata:', indexModule.toolsMetadata)
-    }
-  } catch (error) {
-    console.warn(`   ⚠️  Could not import toolsMetadata, falling back to file parsing`)
-    console.warn(`   Error: ${error instanceof Error ? error.message : String(error)}`)
-    debug('Import error details:', {
-      name: error instanceof Error ? error.name : 'Unknown',
-      message: error instanceof Error ? error.message : String(error),
-      stack: error instanceof Error ? error.stack : 'No stack trace'
-    })
-  }
-
-  debug('Falling back to file parsing')
-  return extractToolsFromIndexFileByParsing(indexPath)
-}
-
-function extractToolsFromIndexFileByParsing(indexPath: string): ToolDefinition[] {
-  const content = readFileSync(indexPath, 'utf8')
-
-  const toolsMatch = content.match(/const\s+tools:\s*ToolDefinition\[\]\s*=\s*\[([\s\S]*?)\n\s*\]/m)
-  if (!toolsMatch) {
-    console.warn('⚠️  Could not find tools array in index.ts')
-    return []
-  }
-
-  const toolsArray = toolsMatch[1]
-  const toolNames: ToolDefinition[] = []
-
-  const toolsSeparated = toolsArray.split(/\n\s*\{/).filter(part => part.includes('name:'))
-  const toolBlocks = toolsSeparated.map((part, idx) => {
-    if (idx === 0) return part
-    return '{' + part
-  })
-
-  for (const block of toolBlocks) {
-    const nameMatch = block.match(/name:\s*["']([^"']+)["']/)
-    const descMatch = block.match(/description:\s*["']([^"']+)["']/)
-
-    const schemaMatch = block.match(/schema:\s*z\.object\(\{([\s\S]*?)\}\),?\s*(?:async\s+execute|$)/)
-
-    if (nameMatch && descMatch) {
-      let schemaProperties: any = {}
-
-      if (schemaMatch) {
-        const schemaContent = schemaMatch[1]
-
-        const lines = schemaContent.split('\n').filter(l => l.trim() && !l.trim().startsWith('//'))
-
-        for (const line of lines) {
-          const propMatch = line.match(/^\s*(\w+):\s*z\.(.+?),?\s*$/)
-          if (!propMatch) continue
-
-          const [, propName, zodDef] = propMatch
-          let propSchema: any = {}
-
-          if (zodDef.includes('string(')) {
-            propSchema.type = 'string'
-          } else if (zodDef.includes('number(')) {
-            propSchema.type = 'number'
-            const minMatch = zodDef.match(/\.min\((\d+)\)/)
-            const maxMatch = zodDef.match(/\.max\((\d+)\)/)
-            if (minMatch) propSchema.minimum = parseInt(minMatch[1])
-            if (maxMatch) propSchema.maximum = parseInt(maxMatch[1])
-          } else if (zodDef.includes('boolean(')) {
-            propSchema.type = 'boolean'
-          } else if (zodDef.includes('enum(')) {
-            propSchema.type = 'string'
-            const enumMatch = zodDef.match(/enum\(\[([^\]]+)\]\)/)
-            if (enumMatch) {
-              const enumValues = enumMatch[1].match(/["']([^"']+)["']/g)?.map(v => v.replace(/["']/g, ''))
-              if (enumValues) propSchema.enum = enumValues
-            }
-          } else if (zodDef.includes('array(')) {
-            propSchema.type = 'array'
-            const arrayTypeMatch = zodDef.match(/array\(z\.(\w+)\(\)\)/)
-            if (arrayTypeMatch) {
-              propSchema.items = { type: arrayTypeMatch[1].toLowerCase() }
-            }
-          }
-
-          if (zodDef.includes('.optional()')) {
-            propSchema.optional = true
-          }
-
-          const descMatch = zodDef.match(/\.describe\(["']([^"']+)["']\)/)
-          if (descMatch) {
-            propSchema.description = descMatch[1]
-          }
-
-          schemaProperties[propName] = propSchema
-        }
-      }
-
-      toolNames.push({
-        name: nameMatch[1],
-        description: descMatch[1],
-        schema: {
-          type: 'object',
-          properties: schemaProperties
-        }
-      })
-    }
-  }
-
-  console.log(`   Found ${toolNames.length} tools in index.ts`)
-  return toolNames
-}
-
-function formatZodSchema(schema: any, depth: number = 0): any {
-  if (!schema || !schema._def) {
-    return { type: 'object', properties: {} }
-  }
-
-  const def = schema._def
-  const zodType = def.typeName || def.type || schema.constructor?.name || 'unknown'
-
-  if (zodType === 'ZodObject' || zodType === 'object') {
-    const properties: any = {}
-    const shapeObj = typeof def.shape === 'function' ? def.shape() : def.shape || {}
-
-    for (const [key, value] of Object.entries(shapeObj)) {
-      properties[key] = formatZodSchema(value, depth + 1)
-    }
-
-    return {
-      type: 'object',
-      properties
-    }
-  }
-
-  if (zodType === 'ZodString' || zodType === 'string') {
-    return { type: 'string' }
-  }
-
-  if (zodType === 'ZodNumber' || zodType === 'number') {
-    const result: any = { type: 'number' }
-    if (def.checks) {
-      for (const check of def.checks) {
-        if (check.kind === 'min') result.minimum = check.value
-        if (check.kind === 'max') result.maximum = check.value
-      }
-    }
-    return result
-  }
-
-  if (zodType === 'ZodBoolean' || zodType === 'boolean') {
-    return { type: 'boolean' }
-  }
-
-  if (zodType === 'ZodArray' || zodType === 'array') {
-    return {
-      type: 'array',
-      items: formatZodSchema(def.type, depth + 1)
-    }
-  }
-
-  if (zodType === 'ZodEnum' || zodType === 'enum') {
-    let values = def.values
-    if (!values && schema._def?.values) {
-      values = schema._def.values
-    }
-    if (!values && schema.options) {
-      values = schema.options
-    }
-
-    const enumArray = Array.isArray(values) ? values : Object.values(values || {})
-    return {
-      type: 'string',
-      enum: enumArray
-    }
-  }
-
-  if (zodType === 'ZodOptional' || zodType === 'optional') {
-    return {
-      ...formatZodSchema(def.innerType, depth + 1),
-      optional: true
-    }
-  }
-
-  return { type: zodType }
-}
-
-function generateToolsMetadata(tools: ToolDefinition[]): Array<{ name: string; description: string; schema: any }> {
-  return tools.map(tool => ({
-    name: tool.name,
-    description: tool.description,
-    schema: tool.schema._def ? formatZodSchema(tool.schema) : tool.schema
-  }))
-}
-
-function generateScriptsFromTools(tools: ToolDefinition[], petName: string): Record<string, string> {
-  const scripts: Record<string, string> = {
-    build: 'pets build',
-    'build:tsc': 'tsc',
-    quickstart: `opencode run "list available ${petName} commands"`,
-  }
-
-  for (const tool of tools) {
-    let scriptName = tool.name
-
-    if (scriptName.startsWith(`${petName}-`)) {
-      scriptName = scriptName.replace(new RegExp(`^${petName}-`), 'test:')
-    } else {
-      scriptName = `test:${scriptName}`
-    }
-
-    const command = `opencode run "${tool.description}"`
-    scripts[scriptName] = command
-  }
-
-  scripts['test:all'] = 'echo "Run individual test scripts to test specific tools"'
-
-  return scripts
-}
-
-export async function buildPet(petName?: string): Promise<void> {
-  debug('=== BUILD PET STARTING ===')
-  debug('Initial petName:', petName)
-  debug('CWD:', process.cwd())
-  debug('Project root:', projectRoot)
-
-  if (!petName) {
-    const cwd = process.cwd()
-    const petsDir = join(projectRoot, 'pets')
-
-    debug('Auto-detecting pet from CWD:', cwd)
-    debug('Pets directory:', petsDir)
-
-    if (cwd.includes('/pets/')) {
-      petName = cwd.split('/pets/')[1].split('/')[0]
-      console.log(`📦 Auto-detected pet: ${petName}`)
-      debug('Auto-detected pet:', petName)
-    }
-
-    if (!petName) {
-      console.error('Usage: pets build <pet-name>')
-      console.error('Example: pets build postgres')
-      console.error('')
-      console.error('Available pets:')
-      if (existsSync(petsDir)) {
-        const pets = readdirSync(petsDir).filter(dir => {
-          const petPath = join(petsDir, dir)
-          return statSync(petPath).isDirectory() && dir !== '_TEMPLATE_'
-        })
-        pets.forEach(pet => console.error(`  - ${pet}`))
-        debug('Available pets:', pets)
-      } else {
-        debug('Pets directory does not exist:', petsDir)
-      }
-      process.exit(1)
-    }
-  }
-
-  const petDir = join(projectRoot, 'pets', petName)
-  const packageJsonPath = join(petDir, 'package.json')
-  const indexPath = join(petDir, 'index.ts')
-
-  debug('Pet directory:', petDir)
-  debug('Package.json path:', packageJsonPath)
-  debug('Index.ts path:', indexPath)
-
-  if (!existsSync(petDir)) {
-    console.error(`❌ Pet '${petName}' not found in pets/ directory`)
-    debug('Pet directory does not exist:', petDir)
-    process.exit(1)
-  }
-
-  if (!existsSync(packageJsonPath)) {
-    console.error(`❌ package.json not found for pet '${petName}'`)
-    debug('Package.json does not exist:', packageJsonPath)
-    process.exit(1)
-  }
-
-  if (!existsSync(indexPath)) {
-    console.error(`❌ index.ts not found for pet '${petName}'`)
-    debug('Index.ts does not exist:', indexPath)
-    process.exit(1)
-  }
-
-  console.log(`🔨 Building ${petName}...`)
-  debug('All required files found, proceeding with build')
-
-  const packageJsonContent = readFileSync(packageJsonPath, 'utf8')
-  debug('Package.json content length:', packageJsonContent.length)
-  const packageJson = JSON.parse(packageJsonContent)
-  debug('Package.json parsed successfully')
-  debug('Package name:', packageJson.name)
-  debug('Package version:', packageJson.version)
-
-  // Auto-generate repository field if missing
-  if (!packageJson.repository) {
-    packageJson.repository = {
-      type: 'git',
-      url: `https://github.com/raggle-ai/pets/pets/${petName}`
-    }
-    debug('Auto-generated repository field:', packageJson.repository.url)
-  }
-
-  console.log(`   Name: ${packageJson.name}`)
-  console.log(`   Version: ${packageJson.version}`)
-  console.log(`   Description: ${packageJson.description || 'No description'}`)
-
-  console.log(`\n🔍 Validating plugin structure...`)
-  const validator = new PluginValidator()
-  const validation = validator.validatePlugin(petDir)
-
-  if (validation.result.errors.length > 0) {
-    console.log(`\n❌ Validation failed with ${validation.result.errors.length} error(s):`)
-    validation.result.errors.forEach(error => {
-      console.log(`   ❌ ${error}`)
-    })
-    console.log(`\n💥 Build aborted due to validation errors.`)
-    process.exit(1)
-  }
-
-  if (validation.result.warnings.length > 0) {
-    console.log(`\n⚠️  Found ${validation.result.warnings.length} warning(s):`)
-    validation.result.warnings.forEach(warning => {
-      console.log(`   ⚠️  ${warning}`)
-    })
-  }
-
-  if (validation.result.codePatternWarnings && validation.result.codePatternWarnings.length > 0) {
-    console.log(`\n📋 Code pattern analysis:`)
-    validation.result.codePatternWarnings.forEach(warning => {
-      console.log(`   ${warning}`)
-    })
-  }
-
-  if (validation.result.errors.length === 0 && validation.result.warnings.length === 0 && (!validation.result.codePatternWarnings || validation.result.codePatternWarnings.length === 0)) {
-    console.log(`   ✓ All validation checks passed`)
-  }
-
-  debug('Extracting tools from index file...')
-  const tools = await extractToolsFromIndexFile(indexPath)
-  debug(`Extracted ${tools.length} tools`)
-
-  if (tools.length > 0) {
-    console.log(`\n📝 Generating scripts and metadata for ${tools.length} tools...`)
-    debug('Tools extracted:', tools.map(t => t.name))
-
-    const scripts = generateScriptsFromTools(tools, petName)
-    debug('Generated scripts:', Object.keys(scripts))
-
-    const toolsMetadata = generateToolsMetadata(tools)
-    debug('Generated tools metadata count:', toolsMetadata.length)
-
-    packageJson.scripts = scripts
-    delete packageJson.tools
-
-    const commandsJsonPath = join(petDir, 'commands.json')
-    debug('Commands.json path:', commandsJsonPath)
-
-    const commandsData = {
-      name: packageJson.name,
-      version: packageJson.version,
-      description: packageJson.description,
-      tools: toolsMetadata,
-      generatedAt: new Date().toISOString()
-    }
-
-    debug('Writing package.json...')
-    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8')
-    debug('Package.json written successfully')
-
-    debug('Writing commands.json...')
-    writeFileSync(commandsJsonPath, JSON.stringify(commandsData, null, 2) + '\n', 'utf8')
-    debug('Commands.json written successfully')
-
-    console.log(`   ✓ Updated package.json with ${Object.keys(scripts).length} scripts`)
-    console.log(`   ✓ Generated commands.json with ${tools.length} tools`)
-
-    console.log(`\n🔧 Generated test scripts:`)
-    Object.entries(scripts).forEach(([name, cmd]) => {
-      if (name.startsWith('test:')) {
-        console.log(`   - npm run ${name}`)
-      }
-    })
-  } else {
-    debug('No tools found in index file')
-  }
-
-  console.log(`\n✅ ${petName} built successfully!`)
-  debug('=== BUILD COMPLETE ===')
-}

package/cli.ts

@@ -1,268 +0,0 @@
-#!/usr/bin/env bun
-
-import { buildPet } from './build-pet.js'
-import { deployPet } from './deploy-pet.js'
-import { addFolderToHistory } from './config-manager.js'
-import { spawn } from 'child_process'
-import { resolve } from 'path'
-import { readFileSync, existsSync } from 'fs'
-
-async function publishPet(petName: string | undefined, options: { preview?: boolean; channel?: string } = {}) {
-  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')}`)
-    process.exit(1)
-  }
-
-  // If no petName provided, try to infer from current directory
-  let finalPetName = petName
-  if (!finalPetName) {
-    const cwd = process.cwd()
-    const pkgPath = resolve(cwd, 'package.json')
-
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
-        // Extract pet name from @openpets/maps -> maps
-        if (pkg.name && pkg.name.startsWith('@openpets/')) {
-          finalPetName = pkg.name.replace('@openpets/', '')
-          console.log(`📦 Detected pet: ${finalPetName}`)
-        }
-      } catch (e) {
-        // Ignore parse errors
-      }
-    }
-
-    if (!finalPetName) {
-      console.error('❌ Could not determine pet name. Run from pet directory or specify pet name.')
-      process.exit(1)
-    }
-  }
-
-  const bunArgs = [scriptPath, finalPetName]
-  if (preview) bunArgs.push('--preview')
-  if (channel && channel !== 'latest') bunArgs.push('--channel', channel)
-
-  return new Promise<void>((resolve, reject) => {
-    const child = spawn('bun', bunArgs, {
-      stdio: 'inherit',
-      shell: true,
-      env: {
-        ...process.env,
-        OPENPETS_PREVIEW: preview ? 'true' : 'false',
-        OPENPETS_CHANNEL: channel
-      }
-    })
-
-    child.on('error', reject)
-    child.on('exit', (code) => {
-      if (code !== 0) {
-        reject(new Error(`Publish exited with code ${code}`))
-      } else {
-        resolve()
-      }
-    })
-  })
-}
-
-const args = process.argv.slice(2)
-const command = args[0]
-
-const DEBUG = process.env.PETS_DEBUG === 'true'
-
-function log(...msgs: any[]) {
-  if (DEBUG) {
-    console.log('[PETS-CLI]', ...msgs)
-  }
-}
-
-function displayInstalledPlugins() {
-  const opencodeJsonPath = resolve(process.cwd(), 'opencode.json')
-
-  log('Looking for opencode.json at:', opencodeJsonPath)
-
-  if (!existsSync(opencodeJsonPath)) {
-    log('opencode.json not found')
-    return
-  }
-
-  try {
-    const content = readFileSync(opencodeJsonPath, 'utf-8')
-    log('opencode.json content length:', content.length)
-
-    const config = JSON.parse(content)
-    log('Parsed opencode.json config:', Object.keys(config))
-
-    if (config.plugin && Array.isArray(config.plugin) && config.plugin.length > 0) {
-      const plugins = config.plugin.filter((p: string) => typeof p === 'string' && p.trim())
-      log('Found plugins:', plugins)
-
-      if (plugins.length > 0) {
-        console.log('\x1b[36m%s\x1b[0m', '📦 Installed plugins:')
-        console.log('\x1b[2m%s\x1b[0m', `   ${plugins.join(', ')}`)
-        console.log('')
-      }
-    } else {
-      log('No plugins found in config')
-    }
-  } catch (error) {
-    log('Error reading opencode.json:', error)
-  }
-}
-
-function killPort(port: number) {
-  log(`Attempting to kill processes on port ${port}`)
-  try {
-    const { execSync } = require('child_process')
-    execSync(`lsof -ti:${port} | xargs kill -9 2>/dev/null || true`, { stdio: 'ignore' })
-    log(`Successfully killed processes on port ${port}`)
-  } catch (error) {
-    log(`No processes to kill on port ${port} or error occurred:`, error)
-  }
-}
-
-function launchManager() {
-  const startTime = Date.now()
-  const uiDir = resolve(__dirname, '../../apps/desktop')
-  const projectDir = process.cwd()
-
-  addFolderToHistory(projectDir)
-
-  console.log('Launching OpenPets Plugin Manager...')
-  console.log(`Project directory: ${projectDir}`)
-  console.log(`UI directory: ${uiDir}`)
-
-  log('Launch details:', {
-    __dirname,
-    uiDir,
-    projectDir,
-    uiDirExists: existsSync(uiDir),
-    timestamp: new Date().toISOString()
-  })
-
-  if (!existsSync(uiDir)) {
-    console.error(`❌ UI directory not found: ${uiDir}`)
-    log('Contents of parent directory:', require('fs').readdirSync(resolve(__dirname, '../../apps')))
-    process.exit(1)
-  }
-
-  log('Checking for package.json in UI directory')
-  const packageJsonPath = resolve(uiDir, 'package.json')
-  if (!existsSync(packageJsonPath)) {
-    console.error(`❌ package.json not found in UI directory: ${packageJsonPath}`)
-    process.exit(1)
-  }
-
-  killPort(1420)
-
-  log('Spawning npm process with tauri:dev')
-  const child = spawn('npm', ['run', 'tauri:dev'], {
-    cwd: uiDir,
-    stdio: 'inherit',
-    shell: true,
-    env: {
-      ...process.env,
-      OPENPETS_PROJECT_DIR: projectDir,
-      PETS_DEBUG: DEBUG ? 'true' : 'false'
-    }
-  })
-
-  log('Child process spawned with PID:', child.pid)
-
-  child.on('error', (error) => {
-    console.error('Failed to launch manager:', error)
-    log('Error details:', {
-      message: error.message,
-      stack: error.stack,
-      elapsed: Date.now() - startTime
-    })
-    process.exit(1)
-  })
-
-  child.on('exit', (code) => {
-    const elapsed = Date.now() - startTime
-    log(`Manager process exited with code ${code} after ${elapsed}ms`)
-    if (code !== 0) {
-      console.error(`Manager exited with code ${code}`)
-      process.exit(code || 1)
-    }
-  })
-}
-
-log('=== PETS CLI STARTUP ===')
-log('Command:', command)
-log('Args:', args)
-log('CWD:', process.cwd())
-log('ENV.OPENPETS_PROJECT_DIR:', process.env.OPENPETS_PROJECT_DIR)
-log('ENV.PETS_DEBUG:', process.env.PETS_DEBUG)
-
-displayInstalledPlugins()
-
-if (command === 'build') {
-  const petName = args[1]
-  log('Building pet:', petName)
-  buildPet(petName).catch(error => {
-    console.error('Error building pet:', error)
-    log('Build error details:', error)
-    process.exit(1)
-  })
-} else if (command === 'deploy') {
-  const petName = args[1]
-  log('Deploying pet:', petName)
-  deployPet(petName).catch(error => {
-    console.error('Error deploying pet:', error)
-    log('Deploy error details:', error)
-    process.exit(1)
-  })
-} else if (command === 'publish') {
-  const petName = args[1] && !args[1].startsWith('--') ? args[1] : undefined
-  const preview = args.includes('--preview')
-  const channelIndex = args.indexOf('--channel')
-  const channel = channelIndex >= 0 ? args[channelIndex + 1] : 'latest'
-
-  log('Publishing pet:', petName || '(auto-detect)', { preview, channel })
-  publishPet(petName, { preview, channel }).catch(error => {
-    console.error('Error publishing pet:', error)
-    log('Publish error details:', error)
-    process.exit(1)
-  })
-} 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')
-  process.exit(1)
-}