@launch77/cli 1.2.0

package/src/modules/deploy/utils/vercel-extended.ts

@@ -0,0 +1,286 @@
+/**
+ * Extended Vercel CLI utilities - Additional helpers for deployment commands
+ */
+
+import { execSync } from 'child_process'
+import * as path from 'path'
+
+import chalk from 'chalk'
+import { execa } from 'execa'
+import fs from 'fs-extra'
+
+/**
+ * Vercel project information from .vercel/project.json
+ */
+export interface VercelProject {
+  projectId: string
+  orgId: string
+  projectName?: string
+}
+
+/**
+ * Vercel project information from API
+ */
+export interface VercelProjectInfo {
+  name: string
+  id: string
+  latestProductionUrl?: string
+  updatedAt: number
+  deprecated: boolean
+}
+
+/**
+ * Check if Vercel CLI is installed globally
+ */
+export async function isVercelCliInstalled(): Promise<boolean> {
+  try {
+    execSync('which vercel', { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Get Vercel installation instructions
+ */
+export function getVercelInstallInstructions(): string {
+  return 'npm install -g vercel'
+}
+
+/**
+ * Load Vercel project information from .vercel/project.json
+ */
+export async function loadVercelProject(appPath: string): Promise<VercelProject | null> {
+  const projectPath = path.join(appPath, '.vercel', 'project.json')
+
+  if (!(await fs.pathExists(projectPath))) {
+    return null
+  }
+
+  try {
+    return await fs.readJSON(projectPath)
+  } catch (error) {
+    console.warn(chalk.yellow('Warning: Could not read .vercel/project.json'))
+    return null
+  }
+}
+
+/**
+ * Run Vercel CLI command with execa
+ */
+export async function runVercelCommand(args: string[], cwd: string, options: { silent?: boolean } = {}): Promise<{ stdout?: string; stderr?: string }> {
+  try {
+    const result = await execa('vercel', args, {
+      cwd,
+      stdio: options.silent ? 'pipe' : 'inherit',
+    })
+    return {
+      stdout: result.stdout || '',
+      stderr: result.stderr || '',
+    }
+  } catch (error) {
+    const errorObj = error as { code?: string }
+    if (errorObj.code === 'ENOENT') {
+      throw new Error('Vercel CLI is not installed. Run: npm install -g vercel')
+    }
+    throw error
+  }
+}
+
+/**
+ * Get package name from package.json
+ */
+export async function getPackageName(appPath: string): Promise<string | null> {
+  const packageJsonPath = path.join(appPath, 'package.json')
+
+  if (!(await fs.pathExists(packageJsonPath))) {
+    return null
+  }
+
+  try {
+    const packageJson = await fs.readJSON(packageJsonPath)
+    return packageJson.name || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Extract Git remote URL from local repository
+ */
+export async function extractGitRemoteUrl(cwd: string): Promise<string | null> {
+  try {
+    const { stdout } = await execa('git', ['config', '--get', 'remote.origin.url'], {
+      cwd,
+      reject: false,
+    })
+
+    if (!stdout) {
+      return null
+    }
+
+    // Convert SSH URLs to HTTPS format for Vercel
+    let url = stdout.trim()
+    if (url.startsWith('git@github.com:')) {
+      url = url.replace('git@github.com:', 'https://github.com/')
+    }
+    if (url.endsWith('.git')) {
+      url = url.slice(0, -4)
+    }
+
+    return url
+  } catch (error) {
+    console.warn(chalk.yellow('Warning: Could not extract Git remote URL'))
+    return null
+  }
+}
+
+/**
+ * Verify if a Vercel project exists
+ */
+export async function verifyVercelProjectExists(projectName: string): Promise<VercelProjectInfo | null> {
+  try {
+    const result = await execa('vercel', ['projects', 'ls', '--json'], {
+      stdio: 'pipe',
+    })
+
+    if (!result.stdout) {
+      return null
+    }
+
+    const data = JSON.parse(result.stdout)
+    const projects = data.projects as VercelProjectInfo[]
+
+    const project = projects.find((p) => p.name === projectName)
+    return project || null
+  } catch (error) {
+    console.warn(chalk.yellow('Warning: Could not verify Vercel project existence'))
+    return null
+  }
+}
+
+/**
+ * Connect Vercel project to Git repository
+ */
+export async function connectGitRepository(appPath: string, gitUrl?: string | null): Promise<boolean> {
+  try {
+    if (!gitUrl) {
+      gitUrl = await extractGitRemoteUrl(appPath)
+      if (!gitUrl) {
+        console.warn(chalk.yellow('Warning: No Git remote URL found'))
+        return false
+      }
+    }
+
+    console.log(chalk.cyan('🔗 Connecting to GitHub repository...'))
+    console.log(chalk.gray(`  Repository: ${gitUrl}`))
+
+    try {
+      const result = await runVercelCommand(['git', 'connect', gitUrl, '--yes'], appPath, {
+        silent: true,
+      })
+
+      const output = (result.stdout || '') + ' ' + (result.stderr || '')
+      if (output.includes('already connected')) {
+        console.log(chalk.green('✅ Repository already connected to GitHub!'))
+        return true
+      }
+
+      console.log(chalk.green('✅ Successfully connected to GitHub!'))
+      return true
+    } catch (gitError) {
+      const errorObj = gitError as {
+        stderr?: string
+        stdout?: string
+        message?: string
+        shortMessage?: string
+      }
+
+      const fullErrorText = [errorObj.message || '', errorObj.shortMessage || '', errorObj.stderr || '', errorObj.stdout || '', String(gitError)].join(' ')
+
+      if (fullErrorText.includes('already connected')) {
+        console.log(chalk.green('✅ Repository already connected to GitHub!'))
+        return true
+      }
+
+      throw gitError
+    }
+  } catch (error) {
+    console.error(chalk.red('❌ Failed to connect to Git repository'))
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    console.error(chalk.gray(errorMessage))
+    return false
+  }
+}
+
+/**
+ * Get Vercel auth token from config
+ */
+async function getVercelAuthToken(): Promise<string | null> {
+  try {
+    let authPath: string
+
+    if (process.platform === 'darwin') {
+      const homeDir = process.env.HOME || ''
+      authPath = path.join(homeDir, 'Library', 'Application Support', 'com.vercel.cli', 'auth.json')
+    } else if (process.platform === 'win32') {
+      const appData = process.env.APPDATA || ''
+      authPath = path.join(appData, 'com.vercel.cli', 'auth.json')
+    } else {
+      const homeDir = process.env.HOME || ''
+      authPath = path.join(homeDir, '.config', 'vercel', 'auth.json')
+    }
+
+    if (!(await fs.pathExists(authPath))) {
+      return null
+    }
+
+    const authData = await fs.readJSON(authPath)
+    return authData.token || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Update Vercel project root directory via REST API
+ */
+export async function updateProjectRootDirectory(projectName: string, rootDirectory: string): Promise<boolean> {
+  try {
+    console.log(chalk.cyan('📁 Setting Root Directory in Vercel...'))
+    console.log(chalk.gray(`  Root Directory: ${rootDirectory}`))
+
+    const token = await getVercelAuthToken()
+    if (!token) {
+      console.warn(chalk.yellow('Warning: Could not get Vercel auth token'))
+      return false
+    }
+
+    const response = await fetch(`https://api.vercel.com/v9/projects/${encodeURIComponent(projectName)}`, {
+      method: 'PATCH',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        rootDirectory,
+      }),
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      console.warn(chalk.yellow(`Warning: Failed to update root directory (${response.status})`))
+      console.warn(chalk.gray(errorText))
+      return false
+    }
+
+    console.log(chalk.green('✅ Root Directory configured!'))
+    return true
+  } catch (error) {
+    console.warn(chalk.yellow('Warning: Failed to update root directory'))
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    console.warn(chalk.gray(errorMessage))
+    return false
+  }
+}

package/src/modules/plugin/commands/plugin-install.ts

@@ -0,0 +1,51 @@
+/* eslint-disable no-console */
+import chalk from 'chalk'
+import { Command } from 'commander'
+import ora from 'ora'
+
+import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+import { PluginService } from '../services/plugin-svc.js'
+
+export function pluginInstallCommand(): Command {
+  const command = new Command('plugin:install')
+    .argument('<plugin-name>', 'Name of the plugin to install (e.g., database)')
+    .description('Install a plugin to the current app')
+    .action(async (pluginName: string) => {
+      try {
+        console.log(chalk.blue(`\n🔌 Installing ${pluginName} plugin\n`))
+
+        // Detect context
+        const context = await detectLaunch77Context(process.cwd())
+
+        // Create plugin service
+        const pluginService = new PluginService()
+
+        // Install files
+        const filesSpinner = ora('Installing plugin files...').start()
+        try {
+          await pluginService.installPlugin({ pluginName }, context)
+          filesSpinner.succeed('Plugin files installed')
+        } catch (error) {
+          filesSpinner.fail('Failed to install plugin')
+          throw error
+        }
+
+        // Package.json update spinner
+        const pkgSpinner = ora('Updating package.json...').start()
+        pkgSpinner.succeed('package.json updated')
+
+        // Dependencies spinner
+        const installSpinner = ora('Installing dependencies...').start()
+        installSpinner.succeed('Dependencies installed')
+
+        // Success message (post-install hook handles custom messages)
+        console.log(chalk.green(`\n✅ Plugin '${pluginName}' installed successfully!\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/plugin/errors/plugin-errors.ts

@@ -0,0 +1,44 @@
+export class PluginNotFoundError extends Error {
+  constructor(pluginName: string) {
+    super(`Plugin '${pluginName}' not found.
+
+Run 'launch77 plugin:list' to see available plugins.`)
+    this.name = 'PluginNotFoundError'
+  }
+}
+
+export class InvalidPluginContextError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'InvalidPluginContextError'
+  }
+}
+
+/**
+ * Factory function to create standardized InvalidPluginContextError
+ * for when plugin:install is run outside of an app directory
+ */
+export function createInvalidContextError(currentLocation: string): InvalidPluginContextError {
+  return new InvalidPluginContextError(
+    `plugin:install must be run from within an app directory.
+
+Current location: ${currentLocation}
+Expected: apps/<app-name>/
+
+Navigate to an app directory:
+  cd apps/<app-name>/
+
+Or create an app first:
+  launch77 app:create api <app-name>`
+  )
+}
+
+export class PluginInstallationError extends Error {
+  constructor(
+    message: string,
+    public readonly cause?: Error
+  ) {
+    super(message)
+    this.name = 'PluginInstallationError'
+  }
+}

package/src/modules/plugin/index.ts

@@ -0,0 +1,14 @@
+// Services
+export { PluginService } from './services/plugin-svc.js'
+
+// Types
+export type { InstallPluginRequest, InstallPluginResult, PluginMetadata, HookResult } from './types/plugin-types.js'
+
+// Errors
+export { PluginNotFoundError, InvalidPluginContextError, PluginInstallationError } from './errors/plugin-errors.js'
+
+// Commands
+export { pluginInstallCommand } from './commands/plugin-install.js'
+
+// Utilities
+export { getPluginPath, pluginExists, listAvailablePlugins } from './lib/plugin-registry.js'

package/src/modules/plugin/lib/launch77-workspace.code-workspace

@@ -0,0 +1,14 @@
+{
+	"folders": [
+		{
+			"path": "../../../../../.."
+		},
+		{
+			"path": "../../../../../../../launch77"
+		},
+		{
+			"path": "../../../../../../../launch-workspaces/fostersauce"
+		}
+	],
+    "settings": {}
+}

package/src/modules/plugin/lib/plugin-registry.ts

@@ -0,0 +1,59 @@
+import * as path from 'path'
+import { fileURLToPath } from 'url'
+
+import fs from 'fs-extra'
+
+/**
+ * Get the path to a plugin directory
+ * Plugins are bundled with the CLI at dist/plugins/
+ */
+export function getPluginPath(pluginName: string): string {
+  const __filename = fileURLToPath(import.meta.url)
+  const __dirname = path.dirname(__filename)
+
+  // From dist/modules/plugin/lib/ to dist/plugins/
+  const baseDir = path.join(__dirname, '../../../plugins')
+
+  return path.join(baseDir, pluginName)
+}
+
+/**
+ * Check if a plugin exists
+ * A plugin must have: dist/generator.js and plugin.json
+ */
+export async function pluginExists(pluginName: string): Promise<boolean> {
+  const pluginPath = getPluginPath(pluginName)
+
+  const hasGenerator = await fs.pathExists(path.join(pluginPath, 'dist/generator.js'))
+  const hasPluginJson = await fs.pathExists(path.join(pluginPath, 'plugin.json'))
+
+  return hasGenerator && hasPluginJson
+}
+
+/**
+ * List all available plugins
+ */
+export async function listAvailablePlugins(): Promise<string[]> {
+  const __filename = fileURLToPath(import.meta.url)
+  const __dirname = path.dirname(__filename)
+
+  const baseDir = path.join(__dirname, '../../../plugins')
+
+  if (!(await fs.pathExists(baseDir))) {
+    return []
+  }
+
+  const items = await fs.readdir(baseDir, { withFileTypes: true })
+  const plugins: string[] = []
+
+  for (const item of items) {
+    if (item.isDirectory()) {
+      // Verify it's a valid plugin
+      if (await pluginExists(item.name)) {
+        plugins.push(item.name)
+      }
+    }
+  }
+
+  return plugins
+}

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

@@ -0,0 +1,53 @@
+import * as path from 'path'
+
+import { execa } from 'execa'
+
+import { PluginInstallationError, PluginNotFoundError, InvalidPluginContextError, createInvalidContextError } from '../errors/plugin-errors.js'
+import { pluginExists, getPluginPath } from '../lib/plugin-registry.js'
+
+import type { Launch77Context } from '../../../utils/launch77-context.js'
+import type { InstallPluginRequest, InstallPluginResult } from '../types/plugin-types.js'
+
+export class PluginService {
+  /**
+   * Install a plugin to the current app
+   */
+  async installPlugin(request: InstallPluginRequest, context: Launch77Context): Promise<InstallPluginResult> {
+    const { pluginName } = request
+
+    // Validate context - must be in app directory
+    if (context.locationType !== 'workspace-app') throw createInvalidContextError(context.locationType)
+    if (!context.appName) throw new InvalidPluginContextError('Could not determine app name. This is a bug. Please report it.')
+
+    // Get app directory path
+    const appPath = path.join(context.appsDir, context.appName)
+
+    // Check if plugin exists
+    if (!(await pluginExists(pluginName))) throw new PluginNotFoundError(pluginName)
+
+    const pluginPath = getPluginPath(pluginName)
+
+    // Run generator
+    await this.runGenerator(pluginPath, appPath, context)
+
+    return {
+      pluginName,
+      filesInstalled: true,
+      packageJsonUpdated: true,
+      dependenciesInstalled: true,
+    }
+  }
+
+  private async runGenerator(pluginPath: string, appPath: string, context: Launch77Context): Promise<void> {
+    try {
+      const generatorPath = path.join(pluginPath, 'dist/generator.js')
+
+      await execa('node', [generatorPath, `--appPath=${appPath}`, `--appName=${context.appName}`, `--workspaceName=${context.workspaceName}`, `--pluginPath=${pluginPath}`], {
+        cwd: pluginPath,
+        stdio: 'inherit',
+      })
+    } catch (error) {
+      throw new PluginInstallationError(`Generator failed: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined)
+    }
+  }
+}

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

@@ -0,0 +1,21 @@
+export interface InstallPluginRequest {
+  pluginName: string
+}
+
+export interface InstallPluginResult {
+  pluginName: string
+  filesInstalled: boolean
+  packageJsonUpdated: boolean
+  dependenciesInstalled: boolean
+}
+
+export interface PluginMetadata {
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  scripts?: Record<string, string>
+}
+
+export interface HookResult {
+  templateVariables?: Record<string, string>
+  hookContext?: Record<string, string>
+}

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

@@ -0,0 +1,53 @@
+import * as path from 'path'
+
+import chalk from 'chalk'
+import { Command } from 'commander'
+import ora from 'ora'
+
+import { detectMonorepoContext } from '../../../utils/monorepo.js'
+import { StartupAlreadyExistsError, InvalidStartupNameError, NotInMonorepoRootError } from '../errors/startup-errors.js'
+import { StartupService } from '../services/startup-service.js'
+
+export function createStartupCommand(): Command {
+  return new Command('startup:create')
+    .argument('<name>', 'Name of the startup (lowercase, alphanumeric, hyphens)')
+    .description('Create a new startup with brand configuration')
+    .action(async (name: string) => {
+      console.log(chalk.blue(`\n🚀 Creating startup: ${name}\n`))
+
+      const service = new StartupService()
+
+      try {
+        const spinner = ora('Creating startup structure...').start()
+
+        // Detect monorepo context
+        const context = await detectMonorepoContext(process.cwd())
+
+        const result = await service.createStartup({ name }, context)
+
+        spinner.succeed('Startup structure created')
+
+        // Success message
+        const cwd = process.cwd()
+        console.log(chalk.green(`\n✅ Startup created successfully at ${path.relative(cwd, result.startupPath)}`))
+        console.log(chalk.gray(`\nNext steps:\n` + `  1. Create your first app:\n` + `     - Web app: launch77 create-app webapp <app-name>\n` + `     - API: launch77 create-app api <app-name>\n` + `     - Marketing site: launch77 create-app marketing-site <app-name>\n`))
+      } catch (error) {
+        if (error instanceof StartupAlreadyExistsError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          process.exit(1)
+        }
+
+        if (error instanceof InvalidStartupNameError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          process.exit(1)
+        }
+
+        if (error instanceof NotInMonorepoRootError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          process.exit(1)
+        }
+
+        throw error
+      }
+    })
+}

package/src/modules/startup/errors/startup-errors.ts

@@ -0,0 +1,23 @@
+export class StartupAlreadyExistsError extends Error {
+  constructor(
+    public startupName: string,
+    public startupPath: string
+  ) {
+    super(`Startup ${startupName} already exists at ${startupPath}`)
+    this.name = 'StartupAlreadyExistsError'
+  }
+}
+
+export class InvalidStartupNameError extends Error {
+  constructor(public startupName: string) {
+    super(`Invalid startup name: "${startupName}"\n\n` + `Startup names must:\n` + `  • Be lowercase only\n` + `  • Can only contain: lowercase letters, numbers, and hyphens\n` + `  • Cannot contain: spaces, uppercase, underscores, periods, or special characters\n\n` + `Valid examples:\n` + `  ✓ my-startup\n` + `  ✓ mystartup\n` + `  ✓ startup123\n\n` + `Invalid examples:\n` + `  ✗ MyStartup (uppercase)\n` + `  ✗ my_startup (underscores)\n` + `  ✗ my.startup (periods)\n` + `  ✗ my startup (spaces)`)
+    this.name = 'InvalidStartupNameError'
+  }
+}
+
+export class NotInMonorepoRootError extends Error {
+  constructor() {
+    super('Must be run from the monorepo root directory (could not find .launch-monorepo-root.md)')
+    this.name = 'NotInMonorepoRootError'
+  }
+}

package/src/modules/startup/index.ts

@@ -0,0 +1,11 @@
+// Services
+export { StartupService } from './services/startup-service.js'
+
+// Types
+export type { CreateStartupRequest, CreateStartupResult } from './types/startup-types.js'
+
+// Errors
+export { StartupAlreadyExistsError, InvalidStartupNameError, NotInMonorepoRootError } from './errors/startup-errors.js'
+
+// Command
+export { createStartupCommand } from './commands/create-startup.js'

package/src/modules/startup/services/startup-service.ts

@@ -0,0 +1,57 @@
+import * as path from 'path'
+import { fileURLToPath } from 'url'
+
+import * as filesystem from '../../../infrastructure/filesystem.js'
+import { StartupAlreadyExistsError, NotInMonorepoRootError } from '../errors/startup-errors.js'
+import { validateStartupName } from '../utils/startup-validators.js'
+
+import type { MonorepoContext } from '../../../utils/monorepo.js'
+import type { CreateStartupRequest, CreateStartupResult } from '../types/startup-types.js'
+
+export class StartupService {
+  async createStartup(request: CreateStartupRequest, context: MonorepoContext): Promise<CreateStartupResult> {
+    const { name } = request
+
+    // 1. Validate name
+    validateStartupName(name)
+
+    // 2. Verify we found the monorepo
+    if (!context.isValid) {
+      throw new NotInMonorepoRootError()
+    }
+
+    // 3. Determine startup path
+    const startupsDir = path.join(context.monorepoRoot, 'startups')
+    const startupPath = path.join(startupsDir, name)
+
+    // 4. Check if startup already exists
+    if (await filesystem.exists(startupPath)) {
+      throw new StartupAlreadyExistsError(name, startupPath)
+    }
+
+    // 5. Ensure startups directory exists
+    await filesystem.ensureDir(startupsDir)
+
+    // 6. Copy template
+    const templatePath = this.getTemplatePath()
+    await filesystem.copy(templatePath, startupPath)
+
+    return {
+      startupPath,
+      name,
+    }
+  }
+
+  private getTemplatePath(): string {
+    const __filename = fileURLToPath(import.meta.url)
+    const __dirname = path.dirname(__filename)
+
+    // From src/modules/startup/services/ or dist/modules/startup/services/ up to cli root
+    const isDev = __filename.includes('/src/')
+    const cliRoot = isDev
+      ? path.join(__dirname, '../../../..') // src/modules/startup/services -> cli root
+      : path.join(__dirname, '../../../..') // dist/modules/startup/services -> cli root
+
+    return path.join(cliRoot, 'templates/startup')
+  }
+}