@launch77/cli 1.2.0 → 1.4.0

package/src/infrastructure/git.ts

@@ -0,0 +1,86 @@
+import { execa } from 'execa'
+
+/**
+ * Check if git is installed
+ */
+export async function isGitInstalled(): Promise<boolean> {
+  try {
+    await execa('git', ['--version'])
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Check if a directory is a git repository
+ */
+export async function isGitRepository(cwd: string): Promise<boolean> {
+  try {
+    await execa('git', ['rev-parse', '--git-dir'], { cwd })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Initialize a git repository
+ */
+export async function gitInit(cwd: string): Promise<void> {
+  await execa('git', ['init'], { cwd })
+}
+
+/**
+ * Check if there are any commits in the repository
+ */
+export async function hasCommits(cwd: string): Promise<boolean> {
+  try {
+    await execa('git', ['rev-parse', 'HEAD'], { cwd })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Stage all files
+ */
+export async function gitAddAll(cwd: string): Promise<void> {
+  await execa('git', ['add', '.'], { cwd })
+}
+
+/**
+ * Create a commit
+ */
+export async function gitCommit(cwd: string, message: string): Promise<void> {
+  await execa('git', ['commit', '-m', message], { cwd })
+}
+
+/**
+ * Get current branch name
+ */
+export async function getCurrentBranch(cwd: string): Promise<string> {
+  const result = await execa('git', ['branch', '--show-current'], { cwd })
+  return result.stdout.trim()
+}
+
+/**
+ * Check if a remote exists
+ */
+export async function hasRemote(cwd: string, remoteName: string): Promise<boolean> {
+  try {
+    await execa('git', ['remote', 'get-url', remoteName], { cwd })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Get the URL of a remote
+ */
+export async function getRemoteUrl(cwd: string, remoteName: string): Promise<string> {
+  const result = await execa('git', ['remote', 'get-url', remoteName], { cwd })
+  return result.stdout.trim()
+}

package/src/infrastructure/github.ts

@@ -0,0 +1,111 @@
+import { execa } from 'execa'
+
+export interface GitHubOwner {
+  login: string
+  type: 'User' | 'Organization'
+}
+
+/**
+ * Check if gh CLI is installed
+ */
+export async function isGhInstalled(): Promise<boolean> {
+  try {
+    await execa('gh', ['--version'])
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Check if gh is authenticated
+ */
+export async function isGhAuthenticated(): Promise<boolean> {
+  try {
+    await execa('gh', ['auth', 'status'])
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Get authenticated user's username
+ */
+export async function getUsername(): Promise<string> {
+  const result = await execa('gh', ['api', 'user', '--jq', '.login'])
+  return result.stdout.trim()
+}
+
+/**
+ * Get user's organizations
+ */
+export async function getOrganizations(): Promise<string[]> {
+  const result = await execa('gh', ['api', 'user/orgs', '--jq', '.[].login'])
+  const output = result.stdout.trim()
+  return output ? output.split('\n') : []
+}
+
+/**
+ * Get all available owners (user + organizations)
+ */
+export async function getAvailableOwners(): Promise<GitHubOwner[]> {
+  const [username, orgs] = await Promise.all([getUsername(), getOrganizations()])
+
+  const owners: GitHubOwner[] = [
+    {
+      login: username,
+      type: 'User',
+    },
+  ]
+
+  for (const org of orgs) {
+    owners.push({
+      login: org,
+      type: 'Organization',
+    })
+  }
+
+  return owners
+}
+
+/**
+ * Create a GitHub repository
+ */
+export async function createRepository(
+  owner: string,
+  repo: string,
+  options: {
+    visibility: 'private' | 'public'
+    cwd: string
+  }
+): Promise<string> {
+  const repoName = `${owner}/${repo}`
+  const visibilityFlag = `--${options.visibility}`
+
+  await execa('gh', ['repo', 'create', repoName, visibilityFlag, '--source=.', '--remote=origin', '--push'], {
+    cwd: options.cwd,
+  })
+
+  // Return the repository URL
+  return `https://github.com/${owner}/${repo}`
+}
+
+/**
+ * Get the current repository information (owner/repo)
+ */
+export async function getCurrentRepository(cwd: string): Promise<{ owner: string; repo: string }> {
+  const result = await execa('gh', ['repo', 'view', '--json', 'owner,name'], { cwd })
+  const data = JSON.parse(result.stdout)
+  return {
+    owner: data.owner.login,
+    repo: data.name,
+  }
+}
+
+/**
+ * Set a repository secret using gh CLI
+ */
+export async function setRepositorySecret(owner: string, repo: string, secretName: string, secretValue: string): Promise<void> {
+  await execa('gh', ['secret', 'set', secretName, '-R', `${owner}/${repo}`, '--body', secretValue])
+}

package/src/infrastructure/template-generator.ts

@@ -1,6 +1,6 @@
 import { getTemplatePath, processTemplate, templateExists } from './template.js'
 
-import type { Launch77Context } from '../utils/launch77-context.js'
+import type { Launch77Context } from '@launch77/plugin-runtime'
 
 export interface GenerateFromTemplateOptions {
   port?: string

package/src/infrastructure/template.ts

@@ -57,6 +57,20 @@ export function getTemplatePath(templateName: string): string {
   return path.join(baseDir, templateName)
 }
 
+/**
+ * Get the path to a plugin template directory
+ * Plugin templates are in dist/templates/ (copied during build)
+ */
+export function getPluginTemplatePath(templateName: string): string {
+  const __filename = fileURLToPath(import.meta.url)
+  const __dirname = path.dirname(__filename)
+
+  // From dist/infrastructure/ to dist/templates/
+  const baseDir = path.join(__dirname, '../templates')
+
+  return path.join(baseDir, templateName)
+}
+
 /**
  * Check if a template exists
  */

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

@@ -5,7 +5,7 @@ import chalk from 'chalk'
 import { Command } from 'commander'
 import ora from 'ora'
 
-import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
 import { AppService } from '../services/app-svc.js'
 import { APP_TYPES, APP_TYPES_LIST } from '../types/app-types.js'
 

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

@@ -6,7 +6,7 @@ import { Command } from 'commander'
 import inquirer from 'inquirer'
 import ora from 'ora'
 
-import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
 import { AppService } from '../services/app-svc.js'
 
 export function deleteAppCommand(): Command {

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

@@ -10,7 +10,7 @@ import { templateExists } from '../../../infrastructure/template.js'
 import { validateWorkspaceContext } from '../../../utils/launch77-validation.js'
 import { validateAppName } from '../../../utils/validation.js'
 
-import type { Launch77Context } from '../../../utils/launch77-context.js'
+import type { Launch77Context } from '@launch77/plugin-runtime'
 import type { CreateAppRequest, CreateAppResult, DeleteAppRequest, DeleteAppResult } from '../types/app-types.js'
 
 export class AppService {

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

@@ -3,7 +3,7 @@ import * as path from 'path'
 
 import { parseManifest } from '../lib/manifest-schema.js'
 
-import type { Launch77Context } from '../../../utils/launch77-context.js'
+import type { Launch77Context } from '@launch77/plugin-runtime'
 import type { AppManifest } from '../lib/manifest-schema.js'
 
 /**

package/src/modules/catalog/config/catalog-config.test.ts

@@ -159,7 +159,7 @@ describe('validateConfig', () => {
         type: 'server-functions',
         packageName: '@launch77/ui',
       }
-      expect(() => validateConfig(config)).toThrow('Type must be "ui-components"')
+      expect(() => validateConfig(config)).toThrow(/expected "ui-components"/)
     })
 
     test('type is number', () => {

package/src/modules/git/commands/git-connect.ts

@@ -0,0 +1,183 @@
+import chalk from 'chalk'
+import { Command } from 'commander'
+import { select, input, confirm } from '@inquirer/prompts'
+import ora from 'ora'
+
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
+import { GitHubCLINotInstalledError, GitHubNotAuthenticatedError, NotInWorkspaceError, GitNotInstalledError } from '../errors/git-errors.js'
+import { GitHubService } from '../services/github-service.js'
+import { GitService } from '../services/git-service.js'
+
+interface ConnectOptions {
+  owner?: string
+  repo?: string
+  private?: boolean
+  public?: boolean
+}
+
+export function gitConnectCommand(): Command {
+  return new Command('git:connect')
+    .description('Connect Launch77 workspace to GitHub repository')
+    .option('--owner <name>', 'GitHub owner (username or organization)')
+    .option('--repo <name>', 'Repository name (defaults to workspace name)')
+    .option('--private', 'Create private repository (default)')
+    .option('--public', 'Create public repository')
+    .action(async (options: ConnectOptions) => {
+      console.log(chalk.blue('\n🔗 Connecting workspace to GitHub...\n'))
+
+      const cwd = process.cwd()
+      const githubService = new GitHubService()
+      const gitService = new GitService()
+
+      try {
+        // 1. Verify we're in a workspace root
+        const context = await detectLaunch77Context(cwd)
+        if (!context.isValid || context.locationType !== 'workspace-root') {
+          throw new NotInWorkspaceError(cwd)
+        }
+
+        // 2. Verify prerequisites
+        const spinner = ora('Checking prerequisites...').start()
+
+        await gitService.verifyGitInstalled()
+        await githubService.verifyPrerequisites()
+
+        spinner.succeed('Prerequisites verified')
+
+        // 3. Check if already connected to a remote
+        const hasOrigin = await gitService.hasRemote(context.workspaceRoot)
+
+        if (hasOrigin) {
+          const remoteUrl = await gitService.getRemoteUrl(context.workspaceRoot)
+
+          console.log(chalk.yellow('\n⚠ This workspace is already connected to a git remote:\n'))
+          console.log(chalk.gray(`   origin: ${chalk.cyan(remoteUrl)}\n`))
+
+          const shouldExit = await confirm({
+            message: 'Workspace already connected. Exit?',
+            default: true,
+          })
+
+          if (shouldExit) {
+            console.log(chalk.green('\n✅ No changes made.\n'))
+            process.exit(0)
+          }
+
+          console.log(chalk.yellow('\n⚠ Continuing may fail if remote "origin" cannot be overwritten...\n'))
+        }
+
+        // 4. Get available owners
+        const availableOwners = await githubService.getAvailableOwners()
+
+        // 5. Determine owner
+        let owner: string
+        if (options.owner) {
+          owner = options.owner
+        } else {
+          const ownerChoices = availableOwners.map((o) => ({
+            name: o.type === 'User' ? `${o.login} (personal)` : o.login,
+            value: o.login,
+          }))
+
+          owner = await select({
+            message: 'Select repository owner:',
+            choices: ownerChoices,
+          })
+        }
+
+        // 6. Determine repository name
+        let repoName: string
+        if (options.repo) {
+          repoName = options.repo
+        } else {
+          repoName = await input({
+            message: 'Repository name:',
+            default: context.workspaceName,
+            validate: (value) => {
+              if (!value || value.trim().length === 0) {
+                return 'Repository name cannot be empty'
+              }
+              // GitHub repo name validation (simplified)
+              const validPattern = /^[a-zA-Z0-9._-]+$/
+              if (!validPattern.test(value)) {
+                return 'Repository name must contain only letters, numbers, dots, hyphens, and underscores'
+              }
+              return true
+            },
+          })
+        }
+
+        // 7. Determine visibility
+        let visibility: 'private' | 'public'
+        if (options.public) {
+          visibility = 'public'
+        } else if (options.private) {
+          visibility = 'private'
+        } else {
+          const visibilityChoice = await select({
+            message: 'Repository visibility:',
+            choices: [
+              { name: 'Private', value: 'private' as const },
+              { name: 'Public', value: 'public' as const },
+            ],
+            default: 'private' as const,
+          })
+          visibility = visibilityChoice
+        }
+
+        // 8. Ensure git repository is ready
+        await gitService.ensureRepositoryReady(context.workspaceRoot)
+
+        // 9. Create GitHub repository and push
+        const createSpinner = ora('Creating GitHub repository and pushing...').start()
+
+        try {
+          const repoUrl = await githubService.createAndPushRepository(owner, repoName, visibility, context.workspaceRoot)
+
+          createSpinner.succeed('Repository created and code pushed')
+
+          // Success message
+          console.log(chalk.green(`\n✅ Workspace connected to GitHub!\n`))
+          console.log(chalk.white(`   Repository: ${chalk.cyan(repoUrl)}\n`))
+          console.log(chalk.gray(`Next steps:\n` + `  - Your code has been pushed to GitHub\n` + `  - GitHub Actions will run automatically\n` + `  - View your repository: ${chalk.cyan('gh repo view --web')}\n` + `\n` + `  ${chalk.yellow('📦 Enable automatic releases (recommended):')}\n` + `  - Run: ${chalk.cyan('launch77 release:init')}\n` + `  - This sets up complete release workflow (GitHub tokens, changesets, npm)\n`))
+        } catch (error) {
+          createSpinner.fail('Failed to create repository')
+
+          // Check if it's a "repository already exists" error
+          if (error instanceof Error && error.message.includes('already exists')) {
+            console.error(chalk.red(`\n❌ Repository ${owner}/${repoName} already exists on GitHub\n`))
+            console.log(chalk.gray(`   View existing repository: ${chalk.cyan(`https://github.com/${owner}/${repoName}`)}\n`))
+          } else {
+            throw error
+          }
+        }
+      } catch (error) {
+        if (error instanceof GitHubCLINotInstalledError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          console.log(chalk.gray(`   Install with: ${chalk.cyan('brew install gh')}\n`))
+          console.log(chalk.gray(`   Or visit: ${chalk.cyan('https://cli.github.com/')}\n`))
+          process.exit(1)
+        }
+
+        if (error instanceof GitHubNotAuthenticatedError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          console.log(chalk.gray(`   Authenticate with: ${chalk.cyan('gh auth login')}\n`))
+          process.exit(1)
+        }
+
+        if (error instanceof NotInWorkspaceError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          console.log(chalk.gray(`   This command must be run from a Launch77 workspace root directory\n`))
+          process.exit(1)
+        }
+
+        if (error instanceof GitNotInstalledError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          console.log(chalk.gray(`   Install git from: ${chalk.cyan('https://git-scm.com/downloads')}\n`))
+          process.exit(1)
+        }
+
+        throw error
+      }
+    })
+}

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

@@ -0,0 +1,44 @@
+export class GitHubCLINotInstalledError extends Error {
+  constructor() {
+    super('GitHub CLI (gh) is not installed')
+    this.name = 'GitHubCLINotInstalledError'
+  }
+}
+
+export class GitHubNotAuthenticatedError extends Error {
+  constructor() {
+    super('GitHub CLI is not authenticated')
+    this.name = 'GitHubNotAuthenticatedError'
+  }
+}
+
+export class NotInWorkspaceError extends Error {
+  constructor(cwd: string) {
+    super(`Not in a Launch77 workspace root. Current directory: ${cwd}`)
+    this.name = 'NotInWorkspaceError'
+  }
+}
+
+export class GitNotInstalledError extends Error {
+  constructor() {
+    super('Git is not installed')
+    this.name = 'GitNotInstalledError'
+  }
+}
+
+export class RepositoryAlreadyExistsError extends Error {
+  constructor(
+    public owner: string,
+    public repo: string
+  ) {
+    super(`Repository ${owner}/${repo} already exists`)
+    this.name = 'RepositoryAlreadyExistsError'
+  }
+}
+
+export class GitHubNotConnectedError extends Error {
+  constructor() {
+    super('This workspace is not connected to a GitHub repository')
+    this.name = 'GitHubNotConnectedError'
+  }
+}

package/src/modules/git/index.ts

@@ -0,0 +1,9 @@
+// Services (for other modules to use)
+export { GitService } from './services/git-service.js'
+export { GitHubService } from './services/github-service.js'
+
+// Errors (for proper error handling)
+export { GitHubCLINotInstalledError, GitHubNotAuthenticatedError, NotInWorkspaceError, GitNotInstalledError, RepositoryAlreadyExistsError, GitHubNotConnectedError } from './errors/git-errors.js'
+
+// Commands
+export { gitConnectCommand } from './commands/git-connect.js'

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

@@ -0,0 +1,63 @@
+import * as git from '../../../infrastructure/git.js'
+import { GitNotInstalledError, GitHubNotConnectedError } from '../errors/git-errors.js'
+
+export class GitService {
+  /**
+   * Verify git is installed
+   */
+  async verifyGitInstalled(): Promise<void> {
+    const isInstalled = await git.isGitInstalled()
+    if (!isInstalled) {
+      throw new GitNotInstalledError()
+    }
+  }
+
+  /**
+   * Initialize git repository if needed and create initial commit if needed
+   */
+  async ensureRepositoryReady(cwd: string): Promise<void> {
+    // Check if git repository exists
+    const isRepo = await git.isGitRepository(cwd)
+
+    if (!isRepo) {
+      console.log('Initializing git repository...')
+      await git.gitInit(cwd)
+      console.log('✓ Git repository initialized')
+    }
+
+    // Check if there are any commits
+    const hasAnyCommits = await git.hasCommits(cwd)
+
+    if (!hasAnyCommits) {
+      console.log('Creating initial commit...')
+      await git.gitAddAll(cwd)
+      await git.gitCommit(cwd, 'Initial commit')
+      console.log('✓ Initial commit created')
+    }
+  }
+
+  /**
+   * Check if repository already has a remote
+   */
+  async hasRemote(cwd: string, remoteName: string = 'origin'): Promise<boolean> {
+    return git.hasRemote(cwd, remoteName)
+  }
+
+  /**
+   * Get the URL of a remote
+   */
+  async getRemoteUrl(cwd: string, remoteName: string = 'origin'): Promise<string> {
+    return git.getRemoteUrl(cwd, remoteName)
+  }
+
+  /**
+   * Ensure repository is connected to GitHub (has a remote)
+   * Throws GitHubNotConnectedError if not connected
+   */
+  async ensureConnectedToGitHub(cwd: string, remoteName: string = 'origin'): Promise<void> {
+    const hasOrigin = await this.hasRemote(cwd, remoteName)
+    if (!hasOrigin) {
+      throw new GitHubNotConnectedError()
+    }
+  }
+}

package/src/modules/git/services/github-service.ts

@@ -0,0 +1,52 @@
+import * as github from '../../../infrastructure/github.js'
+import { GitHubCLINotInstalledError, GitHubNotAuthenticatedError } from '../errors/git-errors.js'
+
+import type { GitHubOwner } from '../../../infrastructure/github.js'
+
+export class GitHubService {
+  /**
+   * Verify GitHub CLI prerequisites (installed and authenticated)
+   */
+  async verifyPrerequisites(): Promise<void> {
+    const isInstalled = await github.isGhInstalled()
+    if (!isInstalled) {
+      throw new GitHubCLINotInstalledError()
+    }
+
+    const isAuthenticated = await github.isGhAuthenticated()
+    if (!isAuthenticated) {
+      throw new GitHubNotAuthenticatedError()
+    }
+  }
+
+  /**
+   * Get all available repository owners (personal + organizations)
+   */
+  async getAvailableOwners(): Promise<GitHubOwner[]> {
+    return github.getAvailableOwners()
+  }
+
+  /**
+   * Create a GitHub repository and push initial commit
+   */
+  async createAndPushRepository(owner: string, repo: string, visibility: 'private' | 'public', cwd: string): Promise<string> {
+    return github.createRepository(owner, repo, {
+      visibility,
+      cwd,
+    })
+  }
+
+  /**
+   * Get the current repository (owner/repo) from the working directory
+   */
+  async getCurrentRepository(cwd: string): Promise<{ owner: string; repo: string }> {
+    return github.getCurrentRepository(cwd)
+  }
+
+  /**
+   * Set a repository secret
+   */
+  async setRepositorySecret(owner: string, repo: string, secretName: string, secretValue: string): Promise<void> {
+    return github.setRepositorySecret(owner, repo, secretName, secretValue)
+  }
+}