Refactor cloneTemplate to use execFile and improve error handling

packages/cli/src/utils/clone-template.ts

@@ -2,7 +2,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import util from 'node:util';
-import shellQuote from 'shell-quote';
 import yoctoSpinner from 'yocto-spinner';
 
 import type { LLMProvider } from '../commands/init/utils';
@@ -12,7 +11,7 @@
 import { logger } from './logger';
 import type { Template } from './template-utils';
 
-const exec = util.promisify(child_process.exec);
+const execFile = util.promisify(child_process.execFile);
 
 export interface CloneTemplateOptions {
   template: Template;
@@ -24,39 +23,45 @@
 
 export async function cloneTemplate(options: CloneTemplateOptions): Promise<string> {
   const { template, projectName, targetDir, branch, llmProvider } = options;
-  const projectPath = targetDir ? path.resolve(targetDir, projectName) : path.resolve(projectName);
+  const projectPath = targetDir
+    ? path.resolve(targetDir, projectName)
+    : path.resolve(projectName);
 
-  const spinner = yoctoSpinner({ text: `Cloning template "${template.title}"...` }).start();
+  const spinner = yoctoSpinner({
+    text: `Cloning template "${template.title}"...`,
+  }).start();
 
   try {
-    // Check if directory already exists
     if (await directoryExists(projectPath)) {
       spinner.error(`Directory ${projectName} already exists`);
       throw new Error(`Directory ${projectName} already exists`);
     }
 
-    // Clone the repository without git history
     await cloneRepositoryWithoutGit(template.githubUrl, projectPath, branch);
 
-    // Update package.json with new project name
     await updatePackageJson(projectPath, projectName);
 
-    // Copy .env.example to .env if it exists, and update MODEL if llmProvider is specified
     const envExamplePath = path.join(projectPath, '.env.example');
     if (await fileExists(envExamplePath)) {
       const envPath = path.join(projectPath, '.env');
       await fs.copyFile(envExamplePath, envPath);
 
-      // Update MODEL in .env if llmProvider is specified
       if (llmProvider) {
         await updateEnvFile(envPath, llmProvider);
       }
     }
 
-    spinner.success(`Template "${template.title}" cloned successfully to ${projectName}`);
+    spinner.success(
+      `Template "${template.title}" cloned successfully to ${projectName}`,
+    );
+
     return projectPath;
   } catch (error) {
-    spinner.error(`Failed to clone template: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    spinner.error(
+      `Failed to clone template: ${
+        error instanceof Error ? error.message : 'Unknown error'
+      }`,
+    );
     throw error;
   }
 }
@@ -79,103 +84,123 @@
   }
 }
 
-async function cloneRepositoryWithoutGit(repoUrl: string, targetPath: string, branch?: string): Promise<void> {
-  // Create target directory
+async function cloneRepositoryWithoutGit(
+  repoUrl: string,
+  targetPath: string,
+  branch?: string,
+): Promise<void> {
   await fs.mkdir(targetPath, { recursive: true });
 
+  // 1. Try degit first
   try {
-    // First try using degit if available (similar to Next.js)
-    const degitRepo = repoUrl.replace('https://github.com/', '');
-    // If branch is specified, append it to the degit repo (format: owner/repo#branch)
-    const degitRepoWithBranch = branch ? `${degitRepo}#${branch}` : degitRepo;
-    const degitCommand = shellQuote.quote(['npx', 'degit', degitRepoWithBranch, targetPath]);
-    await exec(degitCommand, {
+    const repo = repoUrl.replace('https://github.com/', '');
+    const repoWithBranch = branch ? `${repo}#${branch}` : repo;
+
+    await execFile('npx', ['degit', repoWithBranch, targetPath], {
       cwd: process.cwd(),
     });
+
+    return;
   } catch {
-    // Fallback to git clone + remove .git
-    try {
-      const gitArgs = ['git', 'clone'];
-      // Add branch flag if specified
-      if (branch) {
-        gitArgs.push('--branch', branch);
-      }
-      gitArgs.push(repoUrl, targetPath);
+    // fallback to git
+  }
 
-      const gitCommand = shellQuote.quote(gitArgs);
-      await exec(gitCommand, {
-        cwd: process.cwd(),
-      });
+  // 2. Fallback git clone (SAFE VERSION)
+  const args: string[] = ['clone'];
 
-      // Remove .git directory
-      const gitDir = path.join(targetPath, '.git');
-      if (await directoryExists(gitDir)) {
-        await fs.rm(gitDir, { recursive: true, force: true });
-      }
-    } catch (gitError) {
-      throw new Error(`Failed to clone repository: ${gitError instanceof Error ? gitError.message : 'Unknown error'}`);
-    }
+  if (branch) {
+    args.push('--branch', branch);
+  }
+
+  args.push(repoUrl, targetPath);
+
+  await execFile('git', args, {
+    cwd: process.cwd(),
+  });
+
+  // remove .git
+  const gitDir = path.join(targetPath, '.git');
+  if (await directoryExists(gitDir)) {
+    await fs.rm(gitDir, { recursive: true, force: true });
   }
 }
 
-async function updatePackageJson(projectPath: string, projectName: string): Promise<void> {
+async function updatePackageJson(
+  projectPath: string,
+  projectName: string,
+): Promise<void> {
   const packageJsonPath = path.join(projectPath, 'package.json');
 
   try {
     const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
     const packageJson = JSON.parse(packageJsonContent);
 
-    // Update the name field
     packageJson.name = projectName;
 
-    // Write back the updated package.json
-    await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
+    await fs.writeFile(
+      packageJsonPath,
+      JSON.stringify(packageJson, null, 2),
+      'utf-8',
+    );
   } catch (error) {
-    // It's okay if package.json doesn't exist or can't be updated
-    logger.warn('Could not update package.json', { error: error instanceof Error ? error.message : 'Unknown error' });
+    logger.warn('Could not update package.json', {
+      error: error instanceof Error ? error.message : 'Unknown error',
+    });
   }
 }
 
-async function updateEnvFile(envPath: string, llmProvider: LLMProvider): Promise<void> {
+async function updateEnvFile(
+  envPath: string,
+  llmProvider: LLMProvider,
+): Promise<void> {
   try {
     const envContent = await fs.readFile(envPath, 'utf-8');
     const modelString = getModelIdentifier(llmProvider);
 
     if (!modelString) {
-      logger.warn('Could not get model identifier for provider', { provider: llmProvider });
+      logger.warn('Could not get model identifier', { provider: llmProvider });
       return;
     }
 
-    // Remove quotes from modelString (it comes as 'provider/model')
     const modelValue = modelString.replace(/'/g, '');
 
-    // Replace the MODEL line with the selected provider's model
-    const updatedContent = envContent.replace(/^MODEL=.*/m, `MODEL=${modelValue}`);
+    const updatedContent = envContent.replace(
+      /^MODEL=.*/m,
+      `MODEL=${modelValue}`,
+    );
 
     await fs.writeFile(envPath, updatedContent, 'utf-8');
+
     logger.info('Updated MODEL in .env', { model: modelValue });
   } catch (error) {
-    // It's okay if .env can't be updated
-    logger.warn('Could not update .env file', { error: error instanceof Error ? error.message : 'Unknown error' });
+    logger.warn('Could not update .env file', {
+      error: error instanceof Error ? error.message : 'Unknown error',
+    });
   }
 }
 
-export async function installDependencies(projectPath: string, packageManager?: string): Promise<void> {
-  const spinner = yoctoSpinner({ text: 'Installing dependencies...' }).start();
+export async function installDependencies(
+  projectPath: string,
+  packageManager?: string,
+): Promise<void> {
+  const spinner = yoctoSpinner({
+    text: 'Installing dependencies...',
+  }).start();
 
   try {
-    // Use provided package manager or detect from environment/globally
     const pm = packageManager || getPackageManager();
 
-    const installCommand = shellQuote.quote([pm, 'install']);
-
-    await exec(installCommand, {
+    await execFile(pm, ['install'], {
       cwd: projectPath,
     });
 
     spinner.success('Dependencies installed successfully');
   } catch (error) {
-    spinner.error(`Failed to install dependencies: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    spinner.error(
+      `Failed to install dependencies: ${
+        error instanceof Error ? error.message : 'Unknown error'
+      }`,
+    );
     throw error;
   }
 }