@launch77/cli 1.2.0 → 1.3.0

package/src/cli.ts

@@ -5,6 +5,7 @@ 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 { gitConnectCommand, gitSetupReleasesCommand } from './modules/git/index.js'
 import { pluginInstallCommand } from './modules/plugin/index.js'
 import { createStartupCommand } from './modules/startup/index.js'
 import { getPackageVersion } from './utils/version.js'
@@ -26,6 +27,10 @@ program.addCommand(pluginInstallCommand())
 program.addCommand(scanCommand())
 program.addCommand(createGenerateCommand())
 
+// Git commands
+program.addCommand(gitConnectCommand())
+program.addCommand(gitSetupReleasesCommand())
+
 // Deploy commands
 program.addCommand(deployInitCommand())
 program.addCommand(deployStatusCommand())

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/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 '../../../utils/launch77-context.js'
+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 git:setup-releases')}\n` + `  - This sets up the RELEASE_TOKEN for creating release PRs\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/commands/git-setup-releases.ts

@@ -0,0 +1,148 @@
+import chalk from 'chalk'
+import { Command } from 'commander'
+import { password, confirm } from '@inquirer/prompts'
+import ora from 'ora'
+
+import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+import { GitHubCLINotInstalledError, GitHubNotAuthenticatedError, NotInWorkspaceError } from '../errors/git-errors.js'
+import { GitHubService } from '../services/github-service.js'
+import { GitService } from '../services/git-service.js'
+
+interface SetupReleasesOptions {
+  token?: string
+}
+
+export function gitSetupReleasesCommand(): Command {
+  return new Command('git:setup-releases')
+    .description('Configure GitHub RELEASE_TOKEN for automated release PRs')
+    .option('--token <token>', 'Personal Access Token (for automation)')
+    .action(async (options: SetupReleasesOptions) => {
+      console.log(chalk.blue('\n🔐 Setting up GitHub release automation...\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 githubService.verifyPrerequisites()
+
+        spinner.succeed('Prerequisites verified')
+
+        // 3. Check if repository has a remote
+        const hasOrigin = await gitService.hasRemote(context.workspaceRoot)
+        if (!hasOrigin) {
+          console.error(chalk.red('\n❌ This workspace is not connected to a GitHub repository\n'))
+          console.log(chalk.gray(`   Connect to GitHub first: ${chalk.cyan('launch77 git:connect')}\n`))
+          process.exit(1)
+        }
+
+        // 4. Get current repository information
+        const repoSpinner = ora('Detecting repository...').start()
+        const { owner, repo } = await githubService.getCurrentRepository(context.workspaceRoot)
+        repoSpinner.succeed(`Repository: ${owner}/${repo}`)
+
+        // 5. Explain what RELEASE_TOKEN is
+        console.log(chalk.cyan('\n📋 About RELEASE_TOKEN:\n'))
+        console.log(chalk.white('The RELEASE_TOKEN is a GitHub Personal Access Token (PAT) that allows'))
+        console.log(chalk.white('the Changesets action to create Pull Requests for version updates.\n'))
+        console.log(chalk.white('Why is this needed?'))
+        console.log(chalk.gray('  • The default GITHUB_TOKEN has limited permissions'))
+        console.log(chalk.gray('  • Creating PRs that trigger CI requires a PAT'))
+        console.log(chalk.gray('  • This enables automated release workflows\n'))
+        console.log(chalk.white('Required permissions:'))
+        console.log(chalk.gray('  • Contents: Read and write'))
+        console.log(chalk.gray('  • Pull requests: Read and write\n'))
+
+        // 6. Provide link to create PAT
+        const tokenUrl = 'https://github.com/settings/personal-access-tokens/new'
+        console.log(chalk.cyan('🔗 Create your token:'))
+        console.log(chalk.gray(`   ${chalk.cyan(tokenUrl)}`))
+        console.log(chalk.gray(`   Name: Launch77 Release Token`))
+        console.log(chalk.gray(`   Permissions: Contents (Read and write), Pull requests (Read and write)\n`))
+
+        // 7. Get the token (from option or prompt)
+        let token: string
+        if (options.token) {
+          token = options.token
+        } else {
+          token = await password({
+            message: 'Paste your Personal Access Token (PAT):',
+            mask: '*',
+            validate: (value) => {
+              if (!value || value.trim().length === 0) {
+                return 'Token cannot be empty'
+              }
+              // GitHub PATs start with specific prefixes
+              if (!value.startsWith('ghp_') && !value.startsWith('github_pat_')) {
+                return 'Invalid token format. GitHub PATs should start with "ghp_" or "github_pat_"'
+              }
+              return true
+            },
+          })
+        }
+
+        // 8. Confirm if token already might exist
+        console.log(chalk.yellow('\n⚠ Note: This will overwrite any existing RELEASE_TOKEN secret\n'))
+        const shouldContinue = await confirm({
+          message: 'Continue and set RELEASE_TOKEN?',
+          default: true,
+        })
+
+        if (!shouldContinue) {
+          console.log(chalk.green('\n✅ No changes made.\n'))
+          process.exit(0)
+        }
+
+        // 9. Set the repository secret
+        const setSpinner = ora('Setting RELEASE_TOKEN secret...').start()
+
+        try {
+          await githubService.setRepositorySecret(owner, repo, 'RELEASE_TOKEN', token)
+          setSpinner.succeed('RELEASE_TOKEN configured successfully!')
+
+          // Success message
+          console.log(chalk.green('\n✅ Release automation is ready!\n'))
+          console.log(chalk.white('What happens now:'))
+          console.log(chalk.gray('  • When you push to main, CI runs as usual'))
+          console.log(chalk.gray('  • Changesets detects version changes'))
+          console.log(chalk.gray('  • A "Version Packages" PR is created automatically'))
+          console.log(chalk.gray('  • Merge the PR to publish your packages\n'))
+          console.log(chalk.cyan('📚 Learn more:'))
+          console.log(chalk.gray(`   ${chalk.cyan('https://github.com/changesets/changesets')}\n`))
+        } catch (error) {
+          setSpinner.fail('Failed to set RELEASE_TOKEN')
+          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)
+        }
+
+        throw error
+      }
+    })
+}

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

@@ -0,0 +1,37 @@
+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'
+  }
+}

package/src/modules/git/index.ts

@@ -0,0 +1,2 @@
+export { gitConnectCommand } from './commands/git-connect.js'
+export { gitSetupReleasesCommand } from './commands/git-setup-releases.js'

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

@@ -0,0 +1,52 @@
+import * as git from '../../../infrastructure/git.js'
+import { GitNotInstalledError } 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)
+  }
+}

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)
+  }
+}