@launch77/cli 1.4.3 → 1.4.4

package/src/infrastructure/package-resolver.test.ts

@@ -0,0 +1,313 @@
+import * as os from 'os'
+import * as path from 'path'
+
+import fs from 'fs-extra'
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+
+import { PackageResolver } from './package-resolver.js'
+
+/**
+ * Test implementation of PackageResolver for unit testing
+ */
+class TestPackageResolver extends PackageResolver {
+  protected getFolderName(): string {
+    return 'test-packages'
+  }
+
+  protected getPackagePrefix(): string {
+    return '@test-org/test-'
+  }
+
+  protected async verify(localPath: string): Promise<boolean> {
+    // Verify by checking for package.json
+    const packageJsonPath = path.join(localPath, 'package.json')
+    return await fs.pathExists(packageJsonPath)
+  }
+}
+
+describe('PackageResolver', () => {
+  let resolver: TestPackageResolver
+  let tempDir: string
+
+  beforeEach(async () => {
+    resolver = new TestPackageResolver()
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'package-resolver-test-'))
+  })
+
+  afterEach(async () => {
+    await fs.remove(tempDir)
+  })
+
+  describe('validateInput', () => {
+    describe('valid inputs', () => {
+      it('should accept valid unscoped package names', () => {
+        const result = resolver.validateInput('release')
+        expect(result.isValid).toBe(true)
+        expect(result.error).toBeUndefined()
+      })
+
+      it('should accept unscoped names with hyphens', () => {
+        const result = resolver.validateInput('my-package')
+        expect(result.isValid).toBe(true)
+      })
+
+      it('should accept unscoped names with numbers', () => {
+        const result = resolver.validateInput('package-123')
+        expect(result.isValid).toBe(true)
+      })
+
+      it('should accept valid scoped packages', () => {
+        const result = resolver.validateInput('@ibm/analytics')
+        expect(result.isValid).toBe(true)
+        expect(result.error).toBeUndefined()
+      })
+
+      it('should accept scoped packages with hyphens', () => {
+        const result = resolver.validateInput('@launch77-shared/plugin-release')
+        expect(result.isValid).toBe(true)
+      })
+
+      it('should trim whitespace from valid names', () => {
+        const result = resolver.validateInput('  release  ')
+        expect(result.isValid).toBe(true)
+      })
+
+      it('should trim whitespace from scoped names', () => {
+        const result = resolver.validateInput('  @ibm/analytics  ')
+        expect(result.isValid).toBe(true)
+      })
+    })
+
+    describe('invalid inputs', () => {
+      it('should reject empty string', () => {
+        const result = resolver.validateInput('')
+        expect(result.isValid).toBe(false)
+        expect(result.error).toBe('Package name cannot be empty')
+      })
+
+      it('should reject whitespace-only string', () => {
+        const result = resolver.validateInput('   ')
+        expect(result.isValid).toBe(false)
+        expect(result.error).toBe('Package name cannot be empty')
+      })
+
+      it('should reject invalid scoped package without name', () => {
+        const result = resolver.validateInput('@invalid')
+        expect(result.isValid).toBe(false)
+        expect(result.error).toContain('Scoped package must be in format @org/package')
+      })
+
+      it('should reject invalid scoped package without scope', () => {
+        const result = resolver.validateInput('@/package')
+        expect(result.isValid).toBe(false)
+        expect(result.error).toBeDefined()
+      })
+
+      it('should reject invalid scoped package with missing name after slash', () => {
+        const result = resolver.validateInput('@org/')
+        expect(result.isValid).toBe(false)
+        expect(result.error).toContain('Scoped package must be in format @org/package')
+      })
+
+      it('should reject names with uppercase letters', () => {
+        const result = resolver.validateInput('MyPackage')
+        expect(result.isValid).toBe(false)
+        expect(result.error).toBeDefined()
+      })
+
+      it('should reject names starting with numbers', () => {
+        const result = resolver.validateInput('123package')
+        expect(result.isValid).toBe(false)
+        expect(result.error).toBeDefined()
+      })
+
+      it('should reject names with underscores', () => {
+        const result = resolver.validateInput('my_package')
+        expect(result.isValid).toBe(false)
+        expect(result.error).toBeDefined()
+      })
+
+      it('should reject names with spaces', () => {
+        const result = resolver.validateInput('my package')
+        expect(result.isValid).toBe(false)
+        expect(result.error).toBeDefined()
+      })
+    })
+  })
+
+  describe('toNpmPackageName', () => {
+    describe('unscoped names', () => {
+      it('should prefix unscoped package names', () => {
+        const result = resolver.toNpmPackageName('release')
+        expect(result).toBe('@test-org/test-release')
+      })
+
+      it('should prefix unscoped names with hyphens', () => {
+        const result = resolver.toNpmPackageName('my-package')
+        expect(result).toBe('@test-org/test-my-package')
+      })
+
+      it('should trim whitespace from unscoped names', () => {
+        const result = resolver.toNpmPackageName('  release  ')
+        expect(result).toBe('@test-org/test-release')
+      })
+    })
+
+    describe('scoped names', () => {
+      it('should return scoped packages as-is', () => {
+        const result = resolver.toNpmPackageName('@ibm/analytics')
+        expect(result).toBe('@ibm/analytics')
+      })
+
+      it('should return scoped packages with hyphens as-is', () => {
+        const result = resolver.toNpmPackageName('@launch77-shared/plugin-release')
+        expect(result).toBe('@launch77-shared/plugin-release')
+      })
+
+      it('should trim whitespace from scoped names', () => {
+        const result = resolver.toNpmPackageName('  @ibm/analytics  ')
+        expect(result).toBe('@ibm/analytics')
+      })
+    })
+  })
+
+  describe('resolveLocation', () => {
+    describe('local resolution (unscoped names)', () => {
+      it('should resolve to local when valid package exists', async () => {
+        const packageName = 'my-local-package'
+        const localPath = path.join(tempDir, 'test-packages', packageName)
+        await fs.ensureDir(localPath)
+        await fs.writeJSON(path.join(localPath, 'package.json'), { name: packageName })
+
+        const result = await resolver.resolveLocation(packageName, tempDir)
+
+        expect(result.source).toBe('local')
+        expect(result.resolvedName).toBe(packageName)
+        expect(result.localPath).toBe(localPath)
+        expect(result.npmPackage).toBeUndefined()
+      })
+
+      it('should fall back to npm when local directory exists but is invalid', async () => {
+        const packageName = 'invalid-local-package'
+        const localPath = path.join(tempDir, 'test-packages', packageName)
+        await fs.ensureDir(localPath)
+        // Don't create package.json, making it invalid
+
+        const result = await resolver.resolveLocation(packageName, tempDir)
+
+        expect(result.source).toBe('npm')
+        expect(result.resolvedName).toBe(packageName)
+        expect(result.npmPackage).toBe('@test-org/test-invalid-local-package')
+        expect(result.localPath).toBeUndefined()
+      })
+
+      it('should fall back to npm when local directory does not exist', async () => {
+        const packageName = 'nonexistent-package'
+
+        const result = await resolver.resolveLocation(packageName, tempDir)
+
+        expect(result.source).toBe('npm')
+        expect(result.resolvedName).toBe(packageName)
+        expect(result.npmPackage).toBe('@test-org/test-nonexistent-package')
+        expect(result.localPath).toBeUndefined()
+      })
+
+      it('should trim whitespace from package names', async () => {
+        const packageName = 'my-package'
+        const localPath = path.join(tempDir, 'test-packages', packageName)
+        await fs.ensureDir(localPath)
+        await fs.writeJSON(path.join(localPath, 'package.json'), { name: packageName })
+
+        const result = await resolver.resolveLocation('  my-package  ', tempDir)
+
+        expect(result.source).toBe('local')
+        expect(result.resolvedName).toBe(packageName)
+        expect(result.localPath).toBe(localPath)
+      })
+    })
+
+    describe('npm resolution (scoped names)', () => {
+      it('should always resolve scoped packages to npm', async () => {
+        const packageName = '@ibm/analytics'
+
+        const result = await resolver.resolveLocation(packageName, tempDir)
+
+        expect(result.source).toBe('npm')
+        expect(result.resolvedName).toBe(packageName)
+        expect(result.npmPackage).toBe(packageName)
+        expect(result.localPath).toBeUndefined()
+      })
+
+      it('should resolve scoped packages to npm even if local directory exists', async () => {
+        const packageName = '@ibm/analytics'
+        // Create a local directory with the scoped package name (edge case)
+        const localPath = path.join(tempDir, 'test-packages', '@ibm/analytics')
+        await fs.ensureDir(localPath)
+        await fs.writeJSON(path.join(localPath, 'package.json'), { name: packageName })
+
+        const result = await resolver.resolveLocation(packageName, tempDir)
+
+        expect(result.source).toBe('npm')
+        expect(result.resolvedName).toBe(packageName)
+        expect(result.npmPackage).toBe(packageName)
+        expect(result.localPath).toBeUndefined()
+      })
+
+      it('should handle scoped packages with hyphens', async () => {
+        const packageName = '@launch77-shared/plugin-release'
+
+        const result = await resolver.resolveLocation(packageName, tempDir)
+
+        expect(result.source).toBe('npm')
+        expect(result.resolvedName).toBe(packageName)
+        expect(result.npmPackage).toBe(packageName)
+      })
+
+      it('should trim whitespace from scoped package names', async () => {
+        const packageName = '@ibm/analytics'
+
+        const result = await resolver.resolveLocation('  @ibm/analytics  ', tempDir)
+
+        expect(result.source).toBe('npm')
+        expect(result.resolvedName).toBe(packageName)
+        expect(result.npmPackage).toBe(packageName)
+      })
+    })
+
+    describe('edge cases', () => {
+      it('should handle empty workspace test-packages directory', async () => {
+        // Ensure the directory exists but is empty
+        await fs.ensureDir(path.join(tempDir, 'test-packages'))
+
+        const result = await resolver.resolveLocation('some-package', tempDir)
+
+        expect(result.source).toBe('npm')
+        expect(result.resolvedName).toBe('some-package')
+        expect(result.npmPackage).toBe('@test-org/test-some-package')
+      })
+
+      it('should handle missing workspace test-packages directory', async () => {
+        // Don't create the test-packages directory at all
+
+        const result = await resolver.resolveLocation('some-package', tempDir)
+
+        expect(result.source).toBe('npm')
+        expect(result.resolvedName).toBe('some-package')
+        expect(result.npmPackage).toBe('@test-org/test-some-package')
+      })
+
+      it('should handle different workspace root paths', async () => {
+        const customRoot = path.join(tempDir, 'custom', 'workspace')
+        const packageName = 'my-package'
+        const localPath = path.join(customRoot, 'test-packages', packageName)
+        await fs.ensureDir(localPath)
+        await fs.writeJSON(path.join(localPath, 'package.json'), { name: packageName })
+
+        const result = await resolver.resolveLocation(packageName, customRoot)
+
+        expect(result.source).toBe('local')
+        expect(result.localPath).toBe(localPath)
+      })
+    })
+  })
+})

package/src/infrastructure/package-resolver.ts

@@ -0,0 +1,194 @@
+import * as path from 'path'
+
+import { parsePluginName, isValidNpmPackageName } from '@launch77/plugin-runtime'
+import fs from 'fs-extra'
+
+import type { ValidationResult } from '@launch77/plugin-runtime'
+
+/**
+ * Base interface for package resolution results
+ */
+export interface PackageResolution {
+  /** The source of the package */
+  source: 'local' | 'npm'
+  /** The resolved name/package to use */
+  resolvedName: string
+  /** The local path if source is 'local' */
+  localPath?: string
+  /** The npm package name if source is 'npm' */
+  npmPackage?: string
+}
+
+/**
+ * Abstract base class for resolving Launch77 packages
+ *
+ * Provides generic resolution logic for finding packages in:
+ * 1. Local workspace directory (e.g., plugins/, app-templates/)
+ * 2. npm packages with configured prefix (e.g., @launch77-shared/plugin-*, @launch77-shared/app-template-*)
+ *
+ * Concrete implementations must provide:
+ * - Folder name for local resolution
+ * - Package prefix for npm resolution
+ * - Verification logic to validate local packages
+ */
+export abstract class PackageResolver {
+  /**
+   * Get the local folder name where packages of this type are stored
+   * @example 'plugins' or 'app-templates'
+   */
+  protected abstract getFolderName(): string
+
+  /**
+   * Get the npm package prefix for unscoped packages
+   * @example '@launch77-shared/plugin-' or '@launch77-shared/app-template-'
+   */
+  protected abstract getPackagePrefix(): string
+
+  /**
+   * Verify that a local package is valid and complete
+   * @param localPath - The local directory path to verify
+   * @returns true if the package is valid, false otherwise
+   */
+  protected abstract verify(localPath: string): Promise<boolean>
+
+  /**
+   * Validate package input name
+   *
+   * Accepts:
+   * - Unscoped names (e.g., "release", "my-package")
+   * - Scoped npm packages (e.g., "@ibm/package-name")
+   *
+   * Rejects:
+   * - Invalid formats
+   * - Empty strings
+   * - Names with invalid characters
+   *
+   * @param name - The package name to validate
+   * @returns ValidationResult with isValid and optional error message
+   *
+   * @example
+   * validateInput('release') // { isValid: true }
+   * validateInput('@ibm/analytics') // { isValid: true }
+   * validateInput('@invalid') // { isValid: false, error: '...' }
+   */
+  validateInput(name: string): ValidationResult {
+    if (!name || name.trim().length === 0) {
+      return {
+        isValid: false,
+        error: 'Package name cannot be empty',
+      }
+    }
+
+    const trimmedName = name.trim()
+
+    // Parse the name to determine type and validate
+    //TODO: move/rename parsePluginName() to parsePackageName()
+    const parsed = parsePluginName(trimmedName)
+
+    if (!parsed.isValid) {
+      return {
+        isValid: false,
+        error: parsed.error,
+      }
+    }
+
+    // If it's scoped, it must be a valid npm package name
+    if (parsed.type === 'scoped') {
+      return isValidNpmPackageName(trimmedName)
+    }
+
+    // Unscoped names are valid for both local and npm
+    return { isValid: true }
+  }
+
+  /**
+   * Convert an unscoped package name to an npm package name
+   *
+   * Rules:
+   * - Unscoped names: prefix with configured package prefix
+   * - Scoped names: use as-is
+   *
+   * @param name - The package name (must be validated first)
+   * @returns The npm package name
+   *
+   * @example
+   * toNpmPackageName('release') // '@launch77-shared/plugin-release' (for PluginResolver)
+   * toNpmPackageName('@ibm/analytics') // '@ibm/analytics'
+   */
+  toNpmPackageName(name: string): string {
+    const trimmedName = name.trim()
+
+    // If already scoped, use as-is
+    if (trimmedName.startsWith('@')) {
+      return trimmedName
+    }
+
+    // Otherwise, convert using configured prefix
+    return `${this.getPackagePrefix()}${trimmedName}`
+  }
+
+  /**
+   * Resolve package location from name
+   *
+   * Resolution order:
+   * 1. Check local workspace directory (configured by getFolderName())
+   * 2. Verify local package is valid (using verify())
+   * 3. Fall back to npm package name (with configured prefix)
+   *
+   * @param name - The package name to resolve
+   * @param workspaceRoot - The workspace root directory
+   * @returns PackageResolution with source and resolved location
+   *
+   * @example
+   * // Local package found
+   * await resolveLocation('my-package', '/workspace')
+   * // { source: 'local', resolvedName: 'my-package', localPath: '/workspace/plugins/my-package' }
+   *
+   * // Not found locally, resolve to npm
+   * await resolveLocation('release', '/workspace')
+   * // { source: 'npm', resolvedName: 'release', npmPackage: '@launch77-shared/plugin-release' }
+   *
+   * // Scoped package always resolves to npm
+   * await resolveLocation('@ibm/analytics', '/workspace')
+   * // { source: 'npm', resolvedName: '@ibm/analytics', npmPackage: '@ibm/analytics' }
+   */
+  async resolveLocation(name: string, workspaceRoot: string): Promise<PackageResolution> {
+    const trimmedName = name.trim()
+    const parsed = parsePluginName(trimmedName)
+
+    // If scoped, always use npm (local packages are never scoped)
+    if (parsed.type === 'scoped') {
+      return {
+        source: 'npm',
+        resolvedName: trimmedName,
+        npmPackage: trimmedName,
+      }
+    }
+
+    // Check local workspace directory
+    const localPath = path.join(workspaceRoot, this.getFolderName(), trimmedName)
+    const localExists = await fs.pathExists(localPath)
+
+    if (localExists) {
+      // Verify it's a valid package
+      const isValid = await this.verify(localPath)
+
+      if (isValid) {
+        return {
+          source: 'local',
+          resolvedName: trimmedName,
+          localPath,
+        }
+      }
+    }
+
+    // Not found locally or invalid, resolve to npm package
+    const npmPackage = this.toNpmPackageName(trimmedName)
+
+    return {
+      source: 'npm',
+      resolvedName: trimmedName,
+      npmPackage,
+    }
+  }
+}

package/src/modules/app/commands/create-app.ts

@@ -47,8 +47,12 @@ export function createAppCommand(): Command {
         }
 
         // Success message
-        console.log(chalk.green(`\n✅ App created successfully at ${path.relative(process.cwd(), result.appPath)}`))
-        console.log(chalk.gray(`\nRun 'npm run dev' from workspace root to start the server at http://localhost:${port}\n`))
+        const relativeAppPath = path.relative(process.cwd(), result.appPath)
+        console.log(chalk.green(`\n✅ App created successfully at ${relativeAppPath}`))
+        console.log(chalk.gray(`\nNext steps:`))
+        console.log(chalk.gray(`  cd ${relativeAppPath}`))
+        console.log(chalk.gray(`  npm run dev`))
+        console.log(chalk.gray(`\nServer will start at http://localhost:${port}\n`))
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
         console.error(chalk.red('Error:'), message)

package/src/modules/app/lib/app-template-resolver.ts

@@ -0,0 +1,40 @@
+import * as path from 'path'
+
+import fs from 'fs-extra'
+
+import { PackageResolver } from '../../../infrastructure/package-resolver.js'
+
+/**
+ * App template resolver implementation
+ *
+ * Resolves app templates from:
+ * - Local workspace app-templates/ directory
+ * - npm packages with @launch77-shared/app-template- prefix
+ */
+export class AppTemplateResolver extends PackageResolver {
+  protected getFolderName(): string {
+    return 'app-templates'
+  }
+
+  protected getPackagePrefix(): string {
+    return '@launch77-shared/app-template-'
+  }
+
+  protected async verify(localPath: string): Promise<boolean> {
+    // Check for either:
+    // 1. A 'template' subdirectory (preferred structure for npm packages)
+    // 2. Any files at the root (simple local templates)
+    const hasTemplateDir = await fs.pathExists(path.join(localPath, 'template'))
+    if (hasTemplateDir) {
+      return true
+    }
+
+    // Check if directory has any files (not just an empty directory)
+    try {
+      const files = await fs.readdir(localPath)
+      return files.length > 0
+    } catch {
+      return false
+    }
+  }
+}

package/src/modules/app/services/app-svc.ts

@@ -5,19 +5,22 @@ import fs from 'fs-extra'
 import { ManifestService } from './manifest-svc.js'
 import * as filesystem from '../../../infrastructure/filesystem.js'
 import * as npm from '../../../infrastructure/npm.js'
-import { generateFromTemplate } from '../../../infrastructure/template-generator.js'
-import { templateExists } from '../../../infrastructure/template.js'
+import { downloadNpmPackage } from '../../../infrastructure/npm-package.js'
+import { processTemplate } from '../../../infrastructure/template.js'
 import { validateWorkspaceContext } from '../../../utils/launch77-validation.js'
 import { validateAppName } from '../../../utils/validation.js'
+import { AppTemplateResolver } from '../lib/app-template-resolver.js'
 
-import type { Launch77Context } from '@launch77/plugin-runtime'
 import type { CreateAppRequest, CreateAppResult, DeleteAppRequest, DeleteAppResult } from '../types/app-types.js'
+import type { Launch77Context } from '@launch77/plugin-runtime'
 
 export class AppService {
   private manifestService: ManifestService
+  private appTemplateResolver: AppTemplateResolver
 
   constructor() {
     this.manifestService = new ManifestService()
+    this.appTemplateResolver = new AppTemplateResolver()
   }
 
   /**
@@ -38,30 +41,64 @@ export class AppService {
       throw new Error(contextValidation.errorMessage)
     }
 
-    // 3. Determine app path
+    // 3. Validate template name
+    const templateValidation = this.appTemplateResolver.validateInput(type)
+    if (!templateValidation.isValid) {
+      throw new Error(templateValidation.error || `Invalid template name: ${type}`)
+    }
+
+    // 4. Resolve template location
+    const templateResolution = await this.appTemplateResolver.resolveLocation(type, context.workspaceRoot)
+
+    let templatePath: string
+    if (templateResolution.source === 'local') {
+      // Use local template
+      templatePath = templateResolution.localPath!
+    } else {
+      // Download npm template
+      const downloadResult = await downloadNpmPackage({
+        packageName: templateResolution.npmPackage!,
+        workspaceRoot: context.workspaceRoot,
+      })
+
+      // Check if template has a 'template' subdirectory, otherwise use package root
+      const templateSubdir = path.join(downloadResult.packagePath, 'template')
+      if (await fs.pathExists(templateSubdir)) {
+        templatePath = templateSubdir
+      } else {
+        templatePath = downloadResult.packagePath
+      }
+    }
+
+    // 5. Determine app path
     const appPath = path.join(context.appsDir, appName)
 
-    // 4. Check if app already exists
+    // 6. Check if app already exists
     if (await fs.pathExists(appPath)) {
       throw new Error(`App ${appName} already exists at ${appPath}`)
     }
 
-    // 5. Validate template exists
-    if (!(await templateExists(type))) {
-      throw new Error(`Unknown app type: ${type}. Currently supported: api, webapp, marketing-site`)
+    // 7. Verify template path exists
+    if (!(await fs.pathExists(templatePath))) {
+      throw new Error(`Template not found at: ${templatePath}`)
     }
 
-    // 6. Generate from template (context already has packageName computed)
-    await generateFromTemplate(type, appPath, appName, context, { port })
+    // 8. Generate from template (context already has packageName computed)
+    await processTemplate(templatePath, appPath, {
+      appName,
+      workspaceName: context.workspaceName,
+      packageName: context.packageName,
+      port,
+    })
 
-    // 7. Generate and write app manifest
+    // 9. Generate and write app manifest
     const manifest = this.manifestService.generateManifest(type, appName, context, { port })
     const launchDir = path.join(appPath, '.launch')
     await filesystem.ensureDir(launchDir)
     const manifestPath = path.join(launchDir, 'app.json')
     await filesystem.writeJSON(manifestPath, manifest)
 
-    // 8. Install dependencies
+    // 10. Install dependencies
     await npm.install(context.workspaceRoot)
 
     return {