@launch77/cli 1.4.4 → 1.5.0

package/src/infrastructure/package-resolver.ts

@@ -17,6 +17,8 @@ export interface PackageResolution {
   localPath?: string
   /** The npm package name if source is 'npm' */
   npmPackage?: string
+  /** The version from package.json (required for local packages, undefined for npm until installed) */
+  version?: string
 }
 
 /**
@@ -127,6 +129,30 @@ export abstract class PackageResolver {
     return `${this.getPackagePrefix()}${trimmedName}`
   }
 
+  /**
+   * Read version from package.json
+   * @param packagePath - The path to the package directory
+   * @returns The version string from package.json
+   * @throws If package.json doesn't exist, can't be read, or is missing the version field
+   */
+  private async readVersion(packagePath: string): Promise<string> {
+    const packageJsonPath = path.join(packagePath, 'package.json')
+    try {
+      const packageJson = await fs.readJson(packageJsonPath)
+      if (!packageJson.version) {
+        throw new Error(`Invalid package structure: package.json at ${packagePath} is missing required version field. ` + `All Launch77 packages must include a valid package.json with a version field.`)
+      }
+      return packageJson.version
+    } catch (error) {
+      // Re-throw our own error messages
+      if (error instanceof Error && error.message.includes('Invalid package structure')) {
+        throw error
+      }
+      // File not found or invalid JSON
+      throw new Error(`Invalid package structure: package.json not found or invalid at ${packagePath}. ` + `All Launch77 packages must include a valid package.json with a version field.`)
+    }
+  }
+
   /**
    * Resolve package location from name
    *
@@ -134,15 +160,16 @@ export abstract class PackageResolver {
    * 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)
+   * 4. Read version from package.json (if available)
    *
    * @param name - The package name to resolve
    * @param workspaceRoot - The workspace root directory
-   * @returns PackageResolution with source and resolved location
+   * @returns PackageResolution with source, resolved location, and version
    *
    * @example
    * // Local package found
    * await resolveLocation('my-package', '/workspace')
-   * // { source: 'local', resolvedName: 'my-package', localPath: '/workspace/plugins/my-package' }
+   * // { source: 'local', resolvedName: 'my-package', localPath: '/workspace/plugins/my-package', version: '1.0.0' }
    *
    * // Not found locally, resolve to npm
    * await resolveLocation('release', '/workspace')
@@ -174,10 +201,12 @@ export abstract class PackageResolver {
       const isValid = await this.verify(localPath)
 
       if (isValid) {
+        const version = await this.readVersion(localPath)
         return {
           source: 'local',
           resolvedName: trimmedName,
           localPath,
+          version,
         }
       }
     }

package/src/infrastructure/template.ts

@@ -6,7 +6,6 @@ import Handlebars from 'handlebars'
 
 export interface TemplateContext {
   appName: string
-  startupName?: string
   port?: string
   [key: string]: string | number | boolean | undefined
 }

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

@@ -7,27 +7,19 @@ import ora from 'ora'
 
 import { detectLaunch77Context } from '@launch77/plugin-runtime'
 import { AppService } from '../services/app-svc.js'
-import { APP_TYPES, APP_TYPES_LIST } from '../types/app-types.js'
-
-import type { AppType } from '../types/app-types.js'
 
 export function createAppCommand(): Command {
   const command = new Command('app:create')
-    .argument('<type>', 'App type (api, webapp, marketing-site)')
+    .argument('<template>', 'App template name (e.g., webapp, api, marketing-site)')
     .argument('<app-name>', 'Name of the application')
-    .description('Create a new application')
-    .option('-p, --port <port>', 'Default port for the app')
-    .action(async (type: string, appName: string, options) => {
+    .description('Create a new application from a template')
+    .option('-p, --port <port>', 'Default port for the app (default: 3000)')
+    .action(async (template: string, appName: string, options) => {
       try {
-        // Validate app type
-        if (!APP_TYPES.includes(type as AppType)) {
-          throw new Error(`Invalid app type: ${type}\n\nSupported types: ${APP_TYPES_LIST}`)
-        }
-
-        console.log(chalk.blue(`\n🚀 Creating ${type} app: ${appName}\n`))
+        console.log(chalk.blue(`\n🚀 Creating app: ${appName} from template: ${template}\n`))
 
-        // Set default port based on app type
-        const port = options.port || (type === 'marketing-site' || type === 'webapp' ? '3000' : '4000')
+        // Set default port
+        const port = options.port || '3000'
 
         // Detect context
         const context = await detectLaunch77Context(process.cwd())
@@ -39,7 +31,7 @@ export function createAppCommand(): Command {
         const templateSpinner = ora('Generating app structure...').start()
         let result
         try {
-          result = await appService.createApp({ type: type as AppType, appName, port }, context)
+          result = await appService.createApp({ type: template, appName, port }, context)
           templateSpinner.succeed('App structure generated')
         } catch (error) {
           templateSpinner.fail('Failed to generate app structure')

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

@@ -12,7 +12,7 @@ import { AppService } from '../services/app-svc.js'
 export function deleteAppCommand(): Command {
   const command = new Command('app:delete')
     .argument('<app-name>', 'Name of the app to delete')
-    .description('Delete an app from the startup (requires confirmation)')
+    .description('Delete an app from the workspace (requires confirmation)')
     .action(async (appName: string) => {
       try {
         console.log(chalk.yellow(`\n⚠️  WARNING: You are about to delete the app '${appName}'\n`))

package/src/modules/app/commands/validate-manifest.ts

@@ -25,7 +25,6 @@ export function validateManifestCommand(): Command {
         console.log()
         console.log(chalk.cyan('Manifest details:'))
         console.log(chalk.gray('  Schema version:'), manifest.schemaVersion)
-        console.log(chalk.gray('  App type:'), manifest.type)
         console.log(chalk.gray('  Package:'), manifest.package)
 
         if ('name' in manifest && manifest.name) {

package/src/modules/app/index.ts

@@ -3,7 +3,7 @@ export { AppService } from './services/app-svc.js'
 export { ManifestService } from './services/manifest-svc.js'
 
 // Types
-export type { CreateAppRequest, CreateAppResult, DeleteAppRequest, DeleteAppResult, AppType } from './types/app-types.js'
+export type { CreateAppRequest, CreateAppResult, DeleteAppRequest, DeleteAppResult } from './types/app-types.js'
 export type { AppManifest, DeploymentConfig } from './lib/manifest-schema.js'
 
 // Errors
@@ -12,5 +12,4 @@ export { AppAlreadyExistsError, AppNotFoundError, InvalidAppNameError, TemplateN
 // Commands
 export { createAppCommand } from './commands/create-app.js'
 export { deleteAppCommand } from './commands/delete-app.js'
-export { generateManifestCommand } from './commands/generate-manifest.js'
 export { validateManifestCommand } from './commands/validate-manifest.js'

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

@@ -21,6 +21,22 @@ export class AppTemplateResolver extends PackageResolver {
   }
 
   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)

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,6 +1,7 @@
 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'
@@ -12,7 +13,7 @@ import { validateAppName } from '../../../utils/validation.js'
 import { AppTemplateResolver } from '../lib/app-template-resolver.js'
 
 import type { CreateAppRequest, CreateAppResult, DeleteAppRequest, DeleteAppResult } from '../types/app-types.js'
-import type { Launch77Context } from '@launch77/plugin-runtime'
+import type { Launch77Context, TemplateReference, Launch77PackageManifest } from '@launch77/plugin-runtime'
 
 export class AppService {
   private manifestService: ManifestService
@@ -51,9 +52,14 @@ export class AppService {
     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
-      templatePath = templateResolution.localPath!
+      packageRootPath = templateResolution.localPath!
+      templatePath = packageRootPath
+      templateVersion = templateResolution.version! // Local templates always have version after verification
     } else {
       // Download npm template
       const downloadResult = await downloadNpmPackage({
@@ -61,13 +67,20 @@ export class AppService {
         workspaceRoot: context.workspaceRoot,
       })
 
+      packageRootPath = downloadResult.packagePath
+
       // Check if template has a 'template' subdirectory, otherwise use package root
-      const templateSubdir = path.join(downloadResult.packagePath, 'template')
+      const templateSubdir = path.join(packageRootPath, 'template')
       if (await fs.pathExists(templateSubdir)) {
         templatePath = templateSubdir
       } else {
-        templatePath = downloadResult.packagePath
+        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
@@ -91,14 +104,40 @@ export class AppService {
       port,
     })
 
-    // 9. Generate and write app manifest
-    const manifest = this.manifestService.generateManifest(type, appName, context, { 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
+
+    // Write updated package.json
+    await fs.writeJson(appPackageJsonPath, appPackageJson, { spaces: 2 })
+
+    // 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)
 
-    // 10. 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
   }