chore: debug windows

src/services/cli.services.ts

@@ -12,19 +12,24 @@
     return false;
   }
 
-  const args =
-    pm === 'yarn' ? ['global', 'list', '--depth=0'] : ['list', '--depth', '0', '--global'];
+  try {
+    const args =
+        pm === 'yarn' ? ['global', 'list', '--depth=0'] : ['list', '--depth', '0', '--global'];
 
-  let stdout = '';
+    let stdout = '';
 
-  await spawn({
-    command: pm,
-    args,
-    stdout: (output: string) => (stdout += output),
-    silentOut: true
-  });
+    await spawn({
+      command: pm,
+      args,
+      stdout: (output: string) => (stdout += output),
+      silentOut: true
+    });
 
-  return stdout.includes(CLI_PACKAGE);
+    return stdout.includes(CLI_PACKAGE);
+  } catch (_err: unknown) {
+    // According to our tests, on Windows, npm might just throw an error if there are no global lib installed yet. Therefore, we consider here an error as the CLI not being installed yet.
+    return false;
+  }
 };
 
 const install = async () => {

src/services/deps.services.ts

@@ -1,9 +1,11 @@
+import {nonNullish} from '@junobuild/utils';
 import ora from 'ora';
+import type {PopulateInput} from '../types/generator';
 import {spawn} from '../utils/cmd.utils';
 import {whichPMRuns} from '../utils/pm.utils';
 import {confirm} from '../utils/prompts.utils';
 
-export const dependencies = async () => {
+export const dependencies = async ({where}: PopulateInput) => {
   const install = await confirm('Install dependencies?');
 
   if (!install) {
@@ -18,7 +20,8 @@ export const dependencies = async () => {
     await spawn({
       command: pm,
       args: ['install'],
-      silentOut: true
+      silentOut: true,
+      ...(nonNullish(where) && where !== '' && {cwd: where})
     });
   } finally {
     spinner.stop();

src/services/generate.services.ts

@@ -5,7 +5,7 @@
 import ora from 'ora';
 import {JUNO_CDN_URL} from '../constants/constants';
 import {GITHUB_ACTION_DEPLOY} from '../templates/github-actions';
-import type {GeneratorInput} from '../types/generator';
+import type {GeneratorInput, PopulateInput} from '../types/generator';
 import {gunzipFile, untarFile, type UntarOutputFile} from '../utils/compress.utils';
 import {downloadFromURL} from '../utils/download.utils';
 import {
@@ -15,18 +15,7 @@
 } from '../utils/fs.utils';
 import {createDirectory, getLocalFiles, type LocalFileDescriptor} from '../utils/populate.utils';
 
-type PopulateInput = {
-  where: string | null;
-} & Omit<GeneratorInput, 'destination'>;
-
-export const generate = async ({destination, ...rest}: GeneratorInput) => {
-  await populate({
-    where: ['.', ''].includes(destination) ? null : destination,
-    ...rest
-  });
-};
-
-const populate = async ({gitHubAction, ...rest}: PopulateInput) => {
+export const generate = async ({gitHubAction, ...rest}: PopulateInput) => {
   const spinner = ora(`Creating project...`).start();
 
   try {

src/services/project.services.ts

@@ -23,6 +23,17 @@ export const checkForExistingProject = async (): Promise<{initProject: boolean}>
   return {initProject};
 };
 
+const generateProject = async ({destination, ...rest}: GeneratorInput) => {
+  const input = {
+    where: ['.', ''].includes(destination) ? null : destination,
+    ...rest
+  };
+
+  await generate(input);
+
+  await dependencies(input);
+};
+
 export const initNewProject = async (args: string[]): Promise<GeneratorInput> => {
   const userInputs = initArgs(args);
 
@@ -43,9 +54,7 @@ export const initNewProject = async (args: string[]): Promise<GeneratorInput> =>
     localDevelopment
   };
 
-  await generate(input);
-
-  await dependencies();
+  await generateProject(input);
 
   return input;
 };

src/types/generator.ts

@@ -8,3 +8,7 @@ export interface GeneratorInput {
 }
 
 export type ProjectKind = 'website' | 'app';
+
+export type PopulateInput = {
+  where: string | null;
+} & Omit<GeneratorInput, 'destination'>;

src/utils/cmd.utils.ts

@@ -1,3 +1,4 @@
+import {nonNullish} from '@junobuild/utils';
 import {
   spawn as spawnCommand,
   type ChildProcess,
@@ -11,16 +12,21 @@ export const spawn = async ({
   args,
   stdout,
   silentOut = false,
-  silentErrors = false
+  silentErrors = false,
+  cwd
 }: {
   command: string;
+  cwd?: string;
   args?: readonly string[];
   stdout?: (output: string) => void;
   silentOut?: boolean;
   silentErrors?: boolean;
 }): Promise<number | null> => {
   return await new Promise<number | null>((resolve, reject) => {
-    const process: ChildProcessWithoutNullStreams = spawnCommand(command, args);
+    const process: ChildProcessWithoutNullStreams = spawnCommand(command, args, {
+      shell: true,
+      ...(nonNullish(cwd) && {cwd})
+    });
 
     process.stdout.on('data', (data) => {
       if (stdout !== null && stdout !== undefined) {