@launch77/cli 1.4.3 → 1.5.0

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

@@ -0,0 +1,56 @@
+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> {
+    // All Launch77 packages must have package.json with version
+    const hasPackageJson = await fs.pathExists(path.join(localPath, 'package.json'))
+    if (!hasPackageJson) {
+      return false
+    }
+
+    // Verify package.json has a version field
+    try {
+      const packageJson = await fs.readJson(path.join(localPath, 'package.json'))
+      if (!packageJson.version) {
+        return false
+      }
+    } catch {
+      return false
+    }
+
+    // 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/lib/manifest-schema.ts

@@ -1,7 +1,5 @@
 import { z } from 'zod'
 
-import type { AppType } from '../types/app-types.js'
-
 // Deployment configuration
 export type DeploymentConfig = {
   platform: 'vercel'
@@ -14,7 +12,6 @@ export type DeploymentConfig = {
 export type AppManifest = {
   schemaVersion: 1
   name: string
-  type: AppType | 'marketing' // Support both 'marketing' and 'marketing-site'
   package: string
   deployment?: DeploymentConfig
 }
@@ -28,12 +25,10 @@ const deploymentConfigZ = z.object({
 })
 
 // Main manifest schema - strict mode to reject extra fields
-// Note: Manifests store 'marketing' but we accept 'marketing-site' in commands
 export const manifestZ = z
   .object({
     schemaVersion: z.literal(1),
     name: z.string().min(1),
-    type: z.enum(['marketing', 'webapp', 'api']),
     package: z.string().min(1),
     deployment: deploymentConfigZ.optional(),
   })

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

@@ -1,23 +1,27 @@
 import * as path from 'path'
 
 import fs from 'fs-extra'
+import { readTemplateMetadata } from '@launch77/plugin-runtime'
 
 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, TemplateReference, Launch77PackageManifest } from '@launch77/plugin-runtime'
 
 export class AppService {
   private manifestService: ManifestService
+  private appTemplateResolver: AppTemplateResolver
 
   constructor() {
     this.manifestService = new ManifestService()
+    this.appTemplateResolver = new AppTemplateResolver()
   }
 
   /**
@@ -38,30 +42,102 @@ 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
+    let templateVersion: string
+    let packageRootPath: string
+
+    if (templateResolution.source === 'local') {
+      // Use local template
+      packageRootPath = templateResolution.localPath!
+      templatePath = packageRootPath
+      templateVersion = templateResolution.version! // Local templates always have version after verification
+    } else {
+      // Download npm template
+      const downloadResult = await downloadNpmPackage({
+        packageName: templateResolution.npmPackage!,
+        workspaceRoot: context.workspaceRoot,
+      })
+
+      packageRootPath = downloadResult.packagePath
+
+      // Check if template has a 'template' subdirectory, otherwise use package root
+      const templateSubdir = path.join(packageRootPath, 'template')
+      if (await fs.pathExists(templateSubdir)) {
+        templatePath = templateSubdir
+      } else {
+        templatePath = packageRootPath
+      }
+
+      // Read version from downloaded package
+      const packageJsonPath = path.join(packageRootPath, 'package.json')
+      const packageJson = await fs.readJson(packageJsonPath)
+      templateVersion = packageJson.version
+    }
+
+    // 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}`)
+    }
+
+    // 8. Generate from template (context already has packageName computed)
+    await processTemplate(templatePath, appPath, {
+      appName,
+      workspaceName: context.workspaceName,
+      packageName: context.packageName,
+      port,
+    })
+
+    // 9. Read template metadata (currently empty, placeholder for future config)
+    //const templateMetadata = await readTemplateMetadata(templatePath)
+
+    // 10. Write template reference to app's package.json
+    const appPackageJsonPath = path.join(appPath, 'package.json')
+    const appPackageJson = await fs.readJson(appPackageJsonPath)
+
+    // Build template reference - version read from package.json
+    const templatePackage = templateResolution.source === 'npm' ? templateResolution.npmPackage! : templateResolution.resolvedName
+    const templateRef: TemplateReference = {
+      package: templatePackage,
+      version: templateVersion,
+      source: templateResolution.source,
+      createdAt: new Date().toISOString(),
+    }
+
+    // Initialize launch77 manifest structure
+    if (!appPackageJson.launch77) {
+      appPackageJson.launch77 = {}
     }
+    const launch77Manifest = appPackageJson.launch77 as Launch77PackageManifest
+    launch77Manifest.template = templateRef
 
-    // 6. Generate from template (context already has packageName computed)
-    await generateFromTemplate(type, appPath, appName, context, { port })
+    // Write updated package.json
+    await fs.writeJson(appPackageJsonPath, appPackageJson, { spaces: 2 })
 
-    // 7. Generate and write app manifest
-    const manifest = this.manifestService.generateManifest(type, appName, context, { port })
+    // 11. Generate and write app manifest
+    const manifest = this.manifestService.generateManifest(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
+    // 12. Install dependencies
     await npm.install(context.workspaceRoot)
 
     return {

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

@@ -8,7 +8,7 @@ import type { AppManifest } from '../lib/manifest-schema.js'
 
 /**
  * Convert kebab-case to Title Case
- * e.g., "my-startup-name" -> "My Startup Name"
+ * e.g., "my-workspace-name" -> "My Workspace Name"
  */
 function toTitleCase(str: string): string {
   return str
@@ -17,66 +17,17 @@ function toTitleCase(str: string): string {
     .join(' ')
 }
 
-/**
- * Generate a manifest for a marketing app
- */
-function generateMarketingManifest(appName: string, context: Launch77Context): AppManifest {
-  const workspaceName = context.workspaceName
-
-  return {
-    schemaVersion: 1,
-    name: `${toTitleCase(workspaceName)} Marketing`,
-    type: 'marketing',
-    package: `@${workspaceName}/${appName}`,
-  }
-}
-
-/**
- * Generate a manifest for a webapp
- */
-function generateWebappManifest(appName: string, context: Launch77Context): AppManifest {
-  const workspaceName = context.workspaceName
-
-  return {
-    schemaVersion: 1,
-    name: `${toTitleCase(workspaceName)} Web`,
-    type: 'webapp',
-    package: `@${workspaceName}/${appName}`,
-  }
-}
-
-/**
- * Generate a manifest for an API app
- */
-function generateApiManifest(appName: string, context: Launch77Context): AppManifest {
-  const workspaceName = context.workspaceName
-
-  return {
-    schemaVersion: 1,
-    name: `${toTitleCase(workspaceName)} API`,
-    type: 'api',
-    package: `@${workspaceName}/${appName}`,
-  }
-}
-
 export class ManifestService {
   /**
-   * Generate an app manifest based on app type
+   * Generate an app manifest
    */
-  generateManifest(type: string, appName: string, context: Launch77Context, _options: { port?: string }): AppManifest {
-    switch (type) {
-      case 'marketing-site':
-      case 'marketing':
-        return generateMarketingManifest(appName, context)
-
-      case 'webapp':
-        return generateWebappManifest(appName, context)
-
-      case 'api':
-        return generateApiManifest(appName, context)
+  generateManifest(appName: string, context: Launch77Context, _options: { port?: string }): AppManifest {
+    const workspaceName = context.workspaceName
 
-      default:
-        throw new Error(`Unsupported app type for manifest generation: ${type}. Supported types: api, webapp, marketing-site`)
+    return {
+      schemaVersion: 1,
+      name: toTitleCase(workspaceName),
+      package: `@${workspaceName}/${appName}`,
     }
   }
 

package/src/modules/app/types/app-types.ts

@@ -1,12 +1,5 @@
-// Supported app types
-export const APP_TYPES = ['api', 'webapp', 'marketing-site'] as const
-export type AppType = (typeof APP_TYPES)[number]
-
-// Display list for error messages
-export const APP_TYPES_LIST = APP_TYPES.join(', ')
-
 export interface CreateAppRequest {
-  type: AppType
+  type: string
   appName: string
   port: string
 }
@@ -14,7 +7,7 @@ export interface CreateAppRequest {
 export interface CreateAppResult {
   appPath: string
   appName: string
-  type: AppType
+  type: string
 }
 
 export interface DeleteAppRequest {

package/src/modules/catalog/commands/scan.ts

@@ -1,7 +1,7 @@
 import chalk from 'chalk'
 import { Command } from 'commander'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
 
-import { detectMonorepoContext } from '../../../utils/monorepo.js'
 import { CatalogService } from '../services/catalog-svc.js'
 
 /**
@@ -17,10 +17,10 @@ export function scanCommand(): Command {
     .option('--quiet', 'Suppress quality report output')
     .action(async (options) => {
       try {
-        const context = await detectMonorepoContext(process.cwd())
+        const context = await detectLaunch77Context(process.cwd())
 
         if (!context.isValid) {
-          console.error(chalk.red('\n✖ Must be run from within a Launch77 monorepo\n'))
+          console.error(chalk.red('\n✖ Must be run from within a Launch77 workspace\n'))
           process.exit(1)
         }
 

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

@@ -9,7 +9,7 @@ import { scanUILibrary } from '../scanners/ui-component-scanner.js'
 import { generateExamplesFiles } from '../utils/examples-generator.js'
 import { generateQualityReport, printQualityReport } from '../utils/quality-reporter.js'
 
-import type { MonorepoContext } from '../../../utils/monorepo.js'
+import type { Launch77Context } from '@launch77/plugin-runtime'
 import type { ValidationResult, UiComponent } from '../types/catalog-types.js'
 
 export interface ScanCatalogOptions {
@@ -32,13 +32,13 @@ export class CatalogService {
   /**
    * Scan Launch77 codebase and generate catalog.json
    */
-  async scanCatalog(context: MonorepoContext, options: ScanCatalogOptions = {}): Promise<ScanCatalogResult> {
+  async scanCatalog(context: Launch77Context, options: ScanCatalogOptions = {}): Promise<ScanCatalogResult> {
     const strict = options.strict !== false // Default to true (strict mode)
     const quiet = options.quiet || false
 
     console.log(chalk.blue('\n🔍 Scanning Launch77 artifacts...\n'))
 
-    const launch77Root = path.join(context.monorepoRoot, 'launch77')
+    const launch77Root = path.join(context.workspaceRoot, 'launch77')
 
     const spinner = ora('Scanning codebase...').start()
 
@@ -109,7 +109,7 @@ export class CatalogService {
     console.log(chalk.green(`  ✓ Saved to ${path.relative(process.cwd(), catalogPath)}`))
 
     // Sync catalog to Launch77 marketing site
-    const marketingSiteCatalogPath = path.join(context.monorepoRoot, 'startups/launch77/apps/marketing/src/catalog.json')
+    const marketingSiteCatalogPath = path.join(context.workspaceRoot, 'apps/marketing/src/catalog.json')
 
     if (await fs.pathExists(path.dirname(marketingSiteCatalogPath))) {
       await fs.writeFile(marketingSiteCatalogPath, formatted)

package/src/modules/deploy/commands/deploy-init-action.ts

@@ -6,10 +6,10 @@
 import * as path from 'path'
 
 import chalk from 'chalk'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
 import fs from 'fs-extra'
 import ora from 'ora'
 
-import { detectMonorepoContext } from '../../../utils/monorepo.js'
 import { DeployService } from '../services/deploy-svc.js'
 import { connectGitRepository, getPackageName, getVercelInstallInstructions, isVercelCliInstalled, loadVercelProject, runVercelCommand, updateProjectRootDirectory, verifyVercelProjectExists } from '../utils/vercel-extended.js'
 
@@ -23,16 +23,15 @@ interface DeployInitOptions {
 export async function deployInit(options: DeployInitOptions = {}) {
   const deployService = new DeployService()
 
-  // Detect monorepo context
-  const context = await detectMonorepoContext(process.cwd())
+  // Detect Launch77 context
+  const context = await detectLaunch77Context(process.cwd())
 
-  if (context.location !== 'startup-app') {
-    throw new Error('Must be run from within an app directory (e.g., startups/mycompany/apps/myapp)')
+  if (context.locationType !== 'workspace-app') {
+    throw new Error('Must be run from within an app directory (e.g., apps/myapp)')
   }
 
   const appPath = process.cwd()
   const appName = context.appName!
-  const startupName = context.startupName!
 
   console.log(chalk.blue(`\n🚀 Initializing Vercel deployment for ${appName}...\n`))
 
@@ -116,23 +115,27 @@ export async function deployInit(options: DeployInitOptions = {}) {
     throw new Error('Could not read package name from package.json')
   }
 
+  // Check template type from app's package.json
+  const appPackageJsonPath = path.join(appPath, 'package.json')
+  const appPackageJson = await fs.readJson(appPackageJsonPath)
+  const templatePackage = appPackageJson.launch77?.template?.package
+
   console.log(chalk.gray(`App details:`))
   console.log(chalk.gray(`  Name: ${manifest.name}`))
-  console.log(chalk.gray(`  Type: ${manifest.type}`))
   console.log(chalk.gray(`  Package: ${packageName}`))
+  if (templatePackage) {
+    console.log(chalk.gray(`  Template: ${templatePackage}`))
+  }
   console.log()
 
-  // Check if this is an API app - Railway deployment coming soon
-  if (manifest.type === 'api') {
-    console.log(chalk.yellow('⚠️  Railway deployments for API apps are not yet supported'))
-    console.log()
-    console.log(chalk.cyan('Coming soon! For now, you can deploy manually to:'))
-    console.log(chalk.white('  • Railway.app'), chalk.gray('- Simple deployment with databases'))
-    console.log(chalk.white('  • Fly.io'), chalk.gray('- Global edge deployment'))
-    console.log(chalk.white('  • Render.com'), chalk.gray('- Managed cloud hosting'))
+  // Only allow webapp apps to deploy to Vercel
+  const isWebapp = templatePackage === 'webapp' || templatePackage === '@launch77-shared/app-template-webapp'
+
+  if (!isWebapp) {
+    console.log(chalk.yellow('⚠️  Vercel deployment only supports webapp apps'))
+    console.log(chalk.gray('Other app types coming soon'))
     console.log()
-    console.log(chalk.gray('Stay tuned for automated Railway deployment support!'))
-    process.exit(0)
+    process.exit(1)
   }
 
   // Check if vercel.json exists
@@ -160,7 +163,7 @@ export async function deployInit(options: DeployInitOptions = {}) {
   console.log()
 
   try {
-    const suggestedProjectName = `${startupName}--${appName}`
+    const suggestedProjectName = appName
     await runVercelCommand(['link', '--project', suggestedProjectName, '--yes'], appPath)
 
     console.log()
@@ -172,7 +175,7 @@ export async function deployInit(options: DeployInitOptions = {}) {
 
   // Read the created .vercel/project.json to get project info
   const vercelProject = await loadVercelProject(appPath)
-  const projectName = vercelProject?.projectName || `${startupName}--${appName}`
+  const projectName = vercelProject?.projectName || appName
 
   // Update manifest with deployment configuration
   manifest.deployment = {
@@ -187,7 +190,7 @@ export async function deployInit(options: DeployInitOptions = {}) {
 
   // Set Root Directory for monorepo deployments
   console.log()
-  const rootDirectory = `startups/${startupName}/apps/${appName}`
+  const rootDirectory = `apps/${appName}`
   await updateProjectRootDirectory(projectName, rootDirectory)
 
   // Automatically connect to Git repository

package/src/modules/deploy/commands/deploy-logs-action.ts

@@ -3,9 +3,12 @@
  */
 
 /* eslint-disable no-console */
+import * as path from 'path'
+
 import chalk from 'chalk'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
+import fs from 'fs-extra'
 
-import { detectMonorepoContext } from '../../../utils/monorepo.js'
 import { DeployService } from '../services/deploy-svc.js'
 import { getVercelInstallInstructions, isVercelCliInstalled, runVercelCommand } from '../utils/vercel-extended.js'
 
@@ -20,11 +23,11 @@ export interface DeployLogsOptions {
 export async function deployLogs(options: DeployLogsOptions) {
   const deployService = new DeployService()
 
-  // Detect monorepo context
-  const context = await detectMonorepoContext(process.cwd())
+  // Detect Launch77 context
+  const context = await detectLaunch77Context(process.cwd())
 
-  if (context.location !== 'startup-app') {
-    throw new Error('Must be run from within an app directory (e.g., startups/mycompany/apps/myapp)')
+  if (context.locationType !== 'workspace-app') {
+    throw new Error('Must be run from within an app directory (e.g., apps/myapp)')
   }
 
   const appPath = process.cwd()
@@ -34,14 +37,17 @@ export async function deployLogs(options: DeployLogsOptions) {
   // Load manifest
   const manifest = await deployService.loadManifest()
 
-  // Check if this is an API app
-  if (manifest.type === 'api') {
-    console.log(chalk.yellow('⚠️  Railway deployments for API apps are not yet supported'))
-    console.log()
-    console.log(chalk.cyan('Coming soon! For now, you can view logs at:'))
-    console.log(chalk.white('  • Railway.app dashboard'))
-    console.log(chalk.white('  • Fly.io dashboard'))
-    console.log(chalk.white('  • Render.com dashboard'))
+  // Check template type from app's package.json
+  const appPackageJsonPath = path.join(appPath, 'package.json')
+  const appPackageJson = await fs.readJson(appPackageJsonPath)
+  const templatePackage = appPackageJson.launch77?.template?.package
+
+  // Only allow webapp apps to deploy to Vercel
+  const isWebapp = templatePackage === 'webapp' || templatePackage === '@launch77-shared/app-template-webapp'
+
+  if (!isWebapp) {
+    console.log(chalk.yellow('⚠️  Vercel deployment only supports webapp apps'))
+    console.log(chalk.gray('Other app types coming soon'))
     console.log()
     return
   }

package/src/modules/deploy/commands/deploy-status-action.ts

@@ -3,10 +3,13 @@
  */
 
 /* eslint-disable no-console */
+import * as path from 'path'
+
 import chalk from 'chalk'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
+import fs from 'fs-extra'
 import ora from 'ora'
 
-import { detectMonorepoContext } from '../../../utils/monorepo.js'
 import { DeployService } from '../services/deploy-svc.js'
 import { getVercelInstallInstructions, isVercelCliInstalled, runVercelCommand, verifyVercelProjectExists } from '../utils/vercel-extended.js'
 
@@ -16,11 +19,11 @@ import { getVercelInstallInstructions, isVercelCliInstalled, runVercelCommand, v
 export async function deployStatus() {
   const deployService = new DeployService()
 
-  // Detect monorepo context
-  const context = await detectMonorepoContext(process.cwd())
+  // Detect Launch77 context
+  const context = await detectLaunch77Context(process.cwd())
 
-  if (context.location !== 'startup-app') {
-    throw new Error('Must be run from within an app directory (e.g., startups/mycompany/apps/myapp)')
+  if (context.locationType !== 'workspace-app') {
+    throw new Error('Must be run from within an app directory (e.g., apps/myapp)')
   }
 
   const appPath = process.cwd()
@@ -30,14 +33,17 @@ export async function deployStatus() {
   // Load manifest
   const manifest = await deployService.loadManifest()
 
-  // Check if this is an API app
-  if (manifest.type === 'api') {
-    console.log(chalk.yellow('⚠️  Railway deployments for API apps are not yet supported'))
-    console.log()
-    console.log(chalk.cyan('Coming soon! For now, you can check your deployment status at:'))
-    console.log(chalk.white('  • Railway.app dashboard'))
-    console.log(chalk.white('  • Fly.io dashboard'))
-    console.log(chalk.white('  • Render.com dashboard'))
+  // Check template type from app's package.json
+  const appPackageJsonPath = path.join(appPath, 'package.json')
+  const appPackageJson = await fs.readJson(appPackageJsonPath)
+  const templatePackage = appPackageJson.launch77?.template?.package
+
+  // Only allow webapp apps to deploy to Vercel
+  const isWebapp = templatePackage === 'webapp' || templatePackage === '@launch77-shared/app-template-webapp'
+
+  if (!isWebapp) {
+    console.log(chalk.yellow('⚠️  Vercel deployment only supports webapp apps'))
+    console.log(chalk.gray('Other app types coming soon'))
     console.log()
     return
   }