@launch77/cli 1.2.0

package/dist/utils/version.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get the version from package.json
+ * @param importMetaUrl - Pass import.meta.url from the calling module
+ * @returns Version string from package.json
+ */
+export declare function getPackageVersion(importMetaUrl: string): string;
+//# sourceMappingURL=version.d.ts.map

package/dist/utils/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/utils/version.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAM/D"}

package/dist/utils/version.js

@@ -0,0 +1,16 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+/**
+ * Get the version from package.json
+ * @param importMetaUrl - Pass import.meta.url from the calling module
+ * @returns Version string from package.json
+ */
+export function getPackageVersion(importMetaUrl) {
+    const __filename = fileURLToPath(importMetaUrl);
+    const __dirname = dirname(__filename);
+    const packageJsonPath = join(__dirname, '../package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    return packageJson.version;
+}
+//# sourceMappingURL=version.js.map

package/dist/utils/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/utils/version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,IAAI,CAAA;AACjC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAA;AAEnC;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,aAAqB;IACrD,MAAM,UAAU,GAAG,aAAa,CAAC,aAAa,CAAC,CAAA;IAC/C,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;IACrC,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAA;IAC1D,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC,CAAA;IACtE,OAAO,WAAW,CAAC,OAAO,CAAA;AAC5B,CAAC"}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@launch77/cli",
+  "version": "1.2.0",
+  "description": "Launch77 Platform CLI - Refactored",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "launch77": "./dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x dist/cli.js && cp -r templates dist/templates && cp -r src/modules/catalog/schemas dist/modules/catalog/schemas",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix"
+  },
+  "dependencies": {
+    "@types/inquirer": "^9.0.9",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "execa": "^8.0.1",
+    "fs-extra": "^11.2.0",
+    "handlebars": "^4.7.8",
+    "inquirer": "^13.0.2",
+    "ora": "^8.0.1",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.10.6",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
+    "eslint": "^8.56.0",
+    "prettier": "^3.7.4",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3",
+    "vitest": "^4.0.16"
+  },
+  "workspaces": [
+    "apps/*",
+    "libraries/*",
+    "plugins/*",
+    "app-templates/*"
+  ]
+}

package/src/cli.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander'
+
+import { createAppCommand, deleteAppCommand, generateManifestCommand, validateManifestCommand } from './modules/app/index.js'
+import { scanCommand, createGenerateCommand } from './modules/catalog/index.js'
+import { deployInitCommand, deployLogsCommand, deployStatusCommand } from './modules/deploy/index.js'
+import { pluginInstallCommand } from './modules/plugin/index.js'
+import { createStartupCommand } from './modules/startup/index.js'
+import { getPackageVersion } from './utils/version.js'
+import { initWorkspaceCommand } from './modules/workspace/index.js'
+
+const program = new Command()
+  .name('launch77')
+  .description('Launch77 Platform CLI')
+  .version(getPackageVersion(import.meta.url))
+
+// Register module commands
+program.addCommand(initWorkspaceCommand())
+program.addCommand(createStartupCommand())
+program.addCommand(createAppCommand())
+program.addCommand(deleteAppCommand())
+program.addCommand(generateManifestCommand())
+program.addCommand(validateManifestCommand())
+program.addCommand(pluginInstallCommand())
+program.addCommand(scanCommand())
+program.addCommand(createGenerateCommand())
+
+// Deploy commands
+program.addCommand(deployInitCommand())
+program.addCommand(deployStatusCommand())
+program.addCommand(deployLogsCommand())
+
+program.parse()

package/src/infrastructure/filesystem.ts

@@ -0,0 +1,69 @@
+import fs from 'fs-extra'
+
+/**
+ * Check if a file or directory exists
+ */
+export async function exists(path: string): Promise<boolean> {
+  return fs.pathExists(path)
+}
+
+/**
+ * Ensure a directory exists, creating it if necessary
+ */
+export async function ensureDir(path: string): Promise<void> {
+  await fs.ensureDir(path)
+}
+
+/**
+ * Write a file with content
+ */
+export async function writeFile(path: string, content: string): Promise<void> {
+  await fs.writeFile(path, content, 'utf-8')
+}
+
+/**
+ * Write JSON to a file with formatting
+ */
+export async function writeJSON(path: string, data: unknown, spaces = 2): Promise<void> {
+  await fs.writeJSON(path, data, { spaces })
+}
+
+/**
+ * Read a file's content
+ */
+export async function readFile(path: string): Promise<string> {
+  return fs.readFile(path, 'utf-8')
+}
+
+/**
+ * Read JSON from a file
+ */
+export async function readJSON<T = unknown>(path: string): Promise<T> {
+  return fs.readJSON(path)
+}
+
+/**
+ * Copy a file or directory
+ */
+export async function copy(src: string, dest: string): Promise<void> {
+  await fs.copy(src, dest)
+}
+
+/**
+ * Read directory contents
+ */
+export async function readdir(path: string): Promise<string[]> {
+  return fs.readdir(path)
+}
+
+/**
+ * Read directory with file types
+ */
+export async function readdirWithTypes(path: string): Promise<Array<{ name: string; isDirectory: boolean; isFile: boolean }>> {
+  const entries = await fs.readdir(path, { withFileTypes: true })
+  return entries.map((entry) => ({
+    name: entry.name,
+    isDirectory: entry.isDirectory(),
+    isFile: entry.isFile(),
+  }))
+}

package/src/infrastructure/npm.ts

@@ -0,0 +1,18 @@
+import { execa } from 'execa'
+
+/**
+ * Run npm install in a directory
+ */
+export async function runNpmInstall(cwd: string): Promise<void> {
+  await execa('npm', ['install'], {
+    cwd,
+    stdio: 'pipe',
+  })
+}
+
+/**
+ * Alias for runNpmInstall
+ */
+export async function install(cwd: string): Promise<void> {
+  await runNpmInstall(cwd)
+}

package/src/infrastructure/template-engine.ts

@@ -0,0 +1,48 @@
+import * as path from 'path'
+
+import Handlebars from 'handlebars'
+
+import * as filesystem from './filesystem.js'
+
+export interface TemplateContext {
+  [key: string]: string | number | boolean | undefined
+}
+
+/**
+ * Process a single template string with Handlebars
+ */
+export function processTemplateString(template: string, context: TemplateContext): string {
+  const compiledTemplate = Handlebars.compile(template)
+  return compiledTemplate(context)
+}
+
+/**
+ * Process a template directory by copying it to a destination and processing .hbs files
+ */
+export async function processTemplate(templatePath: string, destinationPath: string, context: TemplateContext): Promise<void> {
+  // Ensure destination exists
+  await filesystem.ensureDir(destinationPath)
+
+  // Read all items in template directory
+  const items = await filesystem.readdirWithTypes(templatePath)
+
+  for (const item of items) {
+    const sourcePath = path.join(templatePath, item.name)
+    const isHandlebarsFile = item.name.endsWith('.hbs')
+    const targetName = isHandlebarsFile ? item.name.replace(/\.hbs$/, '') : item.name
+    const targetPath = path.join(destinationPath, targetName)
+
+    if (item.isDirectory) {
+      // Recursively process directories
+      await processTemplate(sourcePath, targetPath, context)
+    } else if (isHandlebarsFile) {
+      // Process Handlebars template
+      const templateContent = await filesystem.readFile(sourcePath)
+      const processedContent = processTemplateString(templateContent, context)
+      await filesystem.writeFile(targetPath, processedContent)
+    } else {
+      // Copy file as-is
+      await filesystem.copy(sourcePath, targetPath)
+    }
+  }
+}

package/src/infrastructure/template-generator.ts

@@ -0,0 +1,26 @@
+import { getTemplatePath, processTemplate, templateExists } from './template.js'
+
+import type { Launch77Context } from '../utils/launch77-context.js'
+
+export interface GenerateFromTemplateOptions {
+  port?: string
+}
+
+/**
+ * Generate an app from a template
+ */
+export async function generateFromTemplate(type: string, appPath: string, appName: string, context: Launch77Context, options: GenerateFromTemplateOptions): Promise<void> {
+  // Check if template exists
+  if (!(await templateExists(type))) throw new Error(`Template not found for type: ${type}`)
+
+  // Get template path
+  const templatePath = getTemplatePath(type)
+
+  // Process template with context
+  await processTemplate(templatePath, appPath, {
+    appName,
+    workspaceName: context.workspaceName,
+    packageName: context.packageName,
+    port: options.port,
+  })
+}

package/src/infrastructure/template.ts

@@ -0,0 +1,66 @@
+import * as path from 'path'
+import { fileURLToPath } from 'url'
+
+import fs from 'fs-extra'
+import Handlebars from 'handlebars'
+
+export interface TemplateContext {
+  appName: string
+  startupName?: string
+  port?: string
+  [key: string]: string | number | boolean | undefined
+}
+
+/**
+ * Process a template directory by copying it to a destination and processing .hbs files
+ */
+export async function processTemplate(templatePath: string, destinationPath: string, context: TemplateContext): Promise<void> {
+  // Ensure destination exists
+  await fs.ensureDir(destinationPath)
+
+  // Read all items in template directory
+  const items = await fs.readdir(templatePath, { withFileTypes: true })
+
+  for (const item of items) {
+    const sourcePath = path.join(templatePath, item.name)
+    const isHandlebarsFile = item.name.endsWith('.hbs')
+    const targetName = isHandlebarsFile ? item.name.replace(/\.hbs$/, '') : item.name
+    const targetPath = path.join(destinationPath, targetName)
+
+    if (item.isDirectory()) {
+      // Recursively process directories
+      await processTemplate(sourcePath, targetPath, context)
+    } else if (isHandlebarsFile) {
+      // Process Handlebars template
+      const templateContent = await fs.readFile(sourcePath, 'utf-8')
+      const template = Handlebars.compile(templateContent)
+      const processedContent = template(context)
+      await fs.writeFile(targetPath, processedContent, 'utf-8')
+    } else {
+      // Copy file as-is
+      await fs.copy(sourcePath, targetPath)
+    }
+  }
+}
+
+/**
+ * Get the path to a template directory
+ * Templates are always in dist/app-templates/ (copied during build)
+ */
+export function getTemplatePath(templateName: string): string {
+  const __filename = fileURLToPath(import.meta.url)
+  const __dirname = path.dirname(__filename)
+
+  // From dist/infrastructure/ to dist/app-templates/
+  const baseDir = path.join(__dirname, '../app-templates')
+
+  return path.join(baseDir, templateName)
+}
+
+/**
+ * Check if a template exists
+ */
+export async function templateExists(templateName: string): Promise<boolean> {
+  const templatePath = getTemplatePath(templateName)
+  return fs.pathExists(templatePath)
+}

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

@@ -0,0 +1,60 @@
+/* eslint-disable no-console */
+import * as path from 'path'
+
+import chalk from 'chalk'
+import { Command } from 'commander'
+import ora from 'ora'
+
+import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+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('<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) => {
+      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`))
+
+        // Set default port based on app type
+        const port = options.port || (type === 'marketing-site' || type === 'webapp' ? '3000' : '4000')
+
+        // Detect context
+        const context = await detectLaunch77Context(process.cwd())
+
+        // Create app service
+        const appService = new AppService()
+
+        // Generate from template
+        const templateSpinner = ora('Generating app structure...').start()
+        let result
+        try {
+          result = await appService.createApp({ type: type as AppType, appName, port }, context)
+          templateSpinner.succeed('App structure generated')
+        } catch (error) {
+          templateSpinner.fail('Failed to generate app structure')
+          throw error
+        }
+
+        // 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`))
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        console.error(chalk.red('Error:'), message)
+        process.exit(1)
+      }
+    })
+
+  return command
+}

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

@@ -0,0 +1,123 @@
+/* eslint-disable no-console */
+import * as path from 'path'
+
+import chalk from 'chalk'
+import { Command } from 'commander'
+import inquirer from 'inquirer'
+import ora from 'ora'
+
+import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+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)')
+    .action(async (appName: string) => {
+      try {
+        console.log(chalk.yellow(`\n⚠️  WARNING: You are about to delete the app '${appName}'\n`))
+
+        // Detect context
+        const context = await detectLaunch77Context(process.cwd())
+
+        // Create app service
+        const appService = new AppService()
+
+        // Get app path for display (before deletion)
+        const appPath = path.join(context.appsDir, appName)
+
+        // Display what will be deleted
+        console.log(chalk.red('App location:'), appPath)
+        console.log(chalk.red('\nThis will permanently delete:'))
+        console.log(chalk.gray('  • All source code and configuration files'))
+        console.log(chalk.gray('  • All node_modules (will be cleaned from monorepo)'))
+        console.log(chalk.gray('  • All build artifacts'))
+
+        console.log(chalk.red('\n⚠️  THIS ACTION CANNOT BE UNDONE!\n'))
+
+        // First confirmation: Type app name
+        const { confirmName } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'confirmName',
+            message: `Type the app name to confirm:`,
+            validate: (input: string) => {
+              if (input === appName) {
+                return true
+              }
+              return `Please type '${appName}' exactly to confirm`
+            },
+          },
+        ])
+
+        if (confirmName !== appName) {
+          console.log(chalk.gray('\n✖ Deletion cancelled\n'))
+          return
+        }
+
+        // Second confirmation: Type DELETE
+        const { confirmDelete } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'confirmDelete',
+            message: 'Type DELETE (all caps) to confirm permanent deletion:',
+            validate: (input: string) => {
+              if (input === 'DELETE') {
+                return true
+              }
+              return 'Please type DELETE (all caps) to confirm'
+            },
+          },
+        ])
+
+        if (confirmDelete !== 'DELETE') {
+          console.log(chalk.gray('\n✖ Deletion cancelled\n'))
+          return
+        }
+
+        // Delete the app
+        const deleteSpinner = ora('Deleting app directory...').start()
+        let result
+        try {
+          result = await appService.deleteApp({ appName }, context)
+          deleteSpinner.succeed('App directory deleted')
+        } catch (error) {
+          deleteSpinner.fail('Failed to delete app directory')
+          throw error
+        }
+
+        // Update dependencies
+        const installSpinner = ora('Updating workspace dependencies...').start()
+        try {
+          // This is already done by app service, just show spinner for consistency
+          installSpinner.succeed('Dependencies updated (package-lock.json cleaned)')
+        } catch (error) {
+          installSpinner.fail('Failed to update dependencies')
+          console.log(chalk.yellow('\n⚠️  You may need to run "npm install" manually at the workspace root\n'))
+        }
+
+        // Success message
+        console.log(chalk.green(`\n✅ App '${appName}' has been deleted\n`))
+
+        // Reminder about Docker cleanup
+        if (result.hadDockerResources) {
+          console.log(chalk.yellow('📝 Remember to clean up Docker resources if needed:'))
+          console.log(chalk.gray('   • Stop and remove containers: docker ps -a | grep ' + appName))
+          console.log(chalk.gray('   • Remove volumes: docker volume ls | grep ' + appName))
+          console.log(chalk.gray('   • Use: docker-compose down -v (if you saved the compose file)\n'))
+        }
+
+        // Reminder about Git
+        console.log(chalk.yellow('📝 Remember to commit the deletion:'))
+        console.log(chalk.gray('   git add -A'))
+        console.log(chalk.gray(`   git commit -m "Remove ${appName} app"`))
+        console.log()
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        console.error(chalk.red('Error:'), message)
+        process.exit(1)
+      }
+    })
+
+  return command
+}

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

@@ -0,0 +1,75 @@
+/* eslint-disable no-console */
+import * as path from 'path'
+
+import chalk from 'chalk'
+import { Command } from 'commander'
+import fs from 'fs-extra'
+import ora from 'ora'
+
+import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+import { ManifestService } from '../services/manifest-svc.js'
+import { APP_TYPES, APP_TYPES_LIST, AppType } from '../types/app-types.js'
+
+export function generateManifestCommand(): Command {
+  const command = new Command('app:generate-manifest')
+    .description('Generate a manifest for an existing app (run from app directory)')
+    .requiredOption('-t, --type <type>', `App type (${APP_TYPES_LIST})`)
+    .option('-p, --port <port>', 'Port for API apps (defaults to 4000)')
+    .option('-f, --force', 'Overwrite existing manifest')
+    .action(async (options) => {
+      try {
+        const context = await detectLaunch77Context(process.cwd())
+
+        if (context.locationType !== 'workspace-app') {
+          throw new Error('Must be run from within an app directory (e.g., apps/myapp)')
+        }
+
+        // Validate app type
+        if (!APP_TYPES.includes(options.type as AppType)) {
+          throw new Error(`Invalid app type: ${options.type}. Supported types: ${APP_TYPES_LIST}`)
+        }
+
+        const appPath = process.cwd()
+        const appName = context.appName!
+
+        console.log(chalk.blue(`\n🔍 Generating manifest for app: ${appName}\n`))
+
+        // Check if manifest already exists
+        const launchDir = path.join(appPath, '.launch')
+        const manifestPath = path.join(launchDir, 'app.json')
+
+        if ((await fs.pathExists(manifestPath)) && !options.force) {
+          console.log(chalk.yellow('⚠️  Manifest already exists at .launch/app.json'))
+          console.log(chalk.gray('Use --force to overwrite'))
+          return
+        }
+
+        // Get port
+        const port = options.port || (options.type === 'api' ? '4000' : '3000')
+
+        // Generate manifest
+        const manifestSpinner = ora('Generating manifest...').start()
+        const manifestService = new ManifestService()
+        const manifest = manifestService.generateManifest(options.type, appName, context, { port })
+
+        // Ensure .launch directory exists
+        await fs.ensureDir(launchDir)
+
+        // Write manifest
+        await fs.writeJSON(manifestPath, manifest, { spaces: 2 })
+        manifestSpinner.succeed('Manifest generated')
+
+        console.log(chalk.green(`\n✅ Manifest created at .launch/app.json`))
+        console.log(chalk.gray('\nManifest details:'))
+        console.log(chalk.gray('  Type:'), manifest.type)
+        console.log(chalk.gray('  Name:'), manifest.name)
+        console.log(chalk.gray('  Package:'), manifest.package)
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        console.error(chalk.red('Error:'), message)
+        process.exit(1)
+      }
+    })
+
+  return command
+}