@pnp/cli-microsoft365 7.5.0 → 7.6.0-beta.443bfd8

package/dist/Auth.js

@@ -144,7 +144,7 @@ export class Auth {
         else {
             if (debug) {
                 if (!accessToken) {
-                    await logger.logToStderr(`No token found for resource ${resource}`);
+                    await logger.logToStderr(`No token found for resource ${resource}.`);
                 }
                 else {
                     await logger.logToStderr(`Access token expired. Token: ${accessToken.accessToken}, ExpiresAt: ${accessToken.expiresOn}`);
@@ -193,9 +193,9 @@ export class Auth {
         const response = await getTokenPromise(resource, logger, debug, fetchNew);
         if (!response) {
             if (debug) {
-                await logger.logToStderr(`getTokenPromise authentication result is null`);
+                await logger.logToStderr('getTokenPromise authentication result is null.');
             }
-            throw `Failed to retrieve an access token. Please try again`;
+            throw 'Failed to retrieve an access token. Please try again.';
         }
         else {
             if (debug) {
@@ -387,7 +387,7 @@ export class Auth {
             scopes: [`${resource}/.default`]
         });
     }
-    async ensureAccessTokenWithCertificate(resource, logger, debug) {
+    async ensureAccessTokenWithCertificate(resource, logger, debug, fetchNew) {
         const nodeForge = (await import('node-forge')).default;
         const { pem, pki, asn1, pkcs12 } = nodeForge;
         if (debug) {
@@ -442,7 +442,8 @@ export class Auth {
         }
         this.clientApplication = await this.getConfidentialClient(logger, debug, this.connection.thumbprint, cert);
         return this.clientApplication.acquireTokenByClientCredential({
-            scopes: [`${resource}/.default`]
+            scopes: [`${resource}/.default`],
+            skipCache: fetchNew
         });
     }
     async ensureAccessTokenWithIdentity(resource, logger, debug) {
@@ -562,10 +563,11 @@ export class Auth {
             }
         }
     }
-    async ensureAccessTokenWithSecret(resource, logger, debug) {
+    async ensureAccessTokenWithSecret(resource, logger, debug, fetchNew) {
         this.clientApplication = await this.getConfidentialClient(logger, debug, undefined, undefined, this.connection.secret);
         return this.clientApplication.acquireTokenByClientCredential({
-            scopes: [`${resource}/.default`]
+            scopes: [`${resource}/.default`],
+            skipCache: fetchNew
         });
     }
     async calculateThumbprint(certificate) {
@@ -579,7 +581,7 @@ export class Auth {
         let resource = url;
         const pos = resource.indexOf('/', 8);
         if (pos > -1) {
-            resource = resource.substr(0, pos);
+            resource = resource.substring(0, pos);
         }
         if (resource === 'https://api.bap.microsoft.com' ||
             resource === 'https://api.powerapps.com' ||

package/dist/cli/cli.js

@@ -98,7 +98,7 @@ async function execute(rawArgs) {
         if (parsedArgs.output !== 'none') {
             printHelp(await getHelpMode(parsedArgs));
         }
-        return Promise.resolve();
+        return;
     }
     delete cli.optionsFromArgs.options._;
     delete cli.optionsFromArgs.options['--'];

package/dist/m365/purview/commands/threatassessment/threatassessment-add.js

@@ -0,0 +1,123 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PurviewThreatAssessmentAddCommand_instances, _PurviewThreatAssessmentAddCommand_initTelemetry, _PurviewThreatAssessmentAddCommand_initOptions, _PurviewThreatAssessmentAddCommand_initValidators, _PurviewThreatAssessmentAddCommand_initOptionSets;
+import request from '../../../../request.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import auth from '../../../../Auth.js';
+import fs from 'fs';
+import path from 'path';
+class PurviewThreatAssessmentAddCommand extends GraphCommand {
+    get name() {
+        return commands.THREATASSESSMENT_ADD;
+    }
+    get description() {
+        return 'Create a threat assessment';
+    }
+    constructor() {
+        super();
+        _PurviewThreatAssessmentAddCommand_instances.add(this);
+        this.allowedTypes = ['file', 'url'];
+        this.allowedExpectedAssessments = ['block', 'unblock'];
+        this.allowedCategories = ['spam', 'phishing', 'malware'];
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentAddCommand_instances, "m", _PurviewThreatAssessmentAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentAddCommand_instances, "m", _PurviewThreatAssessmentAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentAddCommand_instances, "m", _PurviewThreatAssessmentAddCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentAddCommand_instances, "m", _PurviewThreatAssessmentAddCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            if (accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[this.resource].accessToken)) {
+                throw 'This command currently does not support app only permissions.';
+            }
+            if (this.verbose) {
+                await logger.logToStderr(`Adding threat assessment of type ${args.options.type} with expected assessment ${args.options.expectedAssessment} and category ${args.options.category}`);
+            }
+            const requestBody = {
+                expectedAssessment: args.options.expectedAssessment,
+                category: args.options.category,
+                url: args.options.url,
+                contentData: args.options.path && fs.readFileSync(args.options.path).toString('base64'),
+                fileName: args.options.path && path.basename(args.options.path)
+            };
+            switch (args.options.type) {
+                case 'file':
+                    requestBody['@odata.type'] = '#microsoft.graph.fileAssessmentRequest';
+                    break;
+                case 'url':
+                    requestBody['@odata.type'] = '#microsoft.graph.urlAssessmentRequest';
+                    break;
+            }
+            const requestOptions = {
+                url: `${this.resource}/v1.0/informationProtection/threatAssessmentRequests`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                data: requestBody,
+                responseType: 'json'
+            };
+            const response = await request.post(requestOptions);
+            await logger.log(response);
+        }
+        catch (err) {
+            this.handleRejectedODataPromise(err);
+        }
+    }
+}
+_PurviewThreatAssessmentAddCommand_instances = new WeakSet(), _PurviewThreatAssessmentAddCommand_initTelemetry = function _PurviewThreatAssessmentAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            path: typeof args.options.path !== 'undefined',
+            url: typeof args.options.url !== 'undefined'
+        });
+    });
+}, _PurviewThreatAssessmentAddCommand_initOptions = function _PurviewThreatAssessmentAddCommand_initOptions() {
+    this.options.unshift({
+        option: '-t, --type <type>',
+        autocomplete: this.allowedTypes
+    }, {
+        option: '-e, --expectedAssessment <expectedAssessment>',
+        autocomplete: this.allowedExpectedAssessments
+    }, {
+        option: '-c, --category <category>',
+        autocomplete: this.allowedCategories
+    }, {
+        option: '-p, --path [path]'
+    }, {
+        option: '-u, --url [url]'
+    });
+}, _PurviewThreatAssessmentAddCommand_initValidators = function _PurviewThreatAssessmentAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (!this.allowedTypes.some(type => type === args.options.type)) {
+            return `${args.options.type} is not an allowed type. Allowed types are ${this.allowedTypes.join('|')}`;
+        }
+        if (!this.allowedExpectedAssessments.some(expectedAssessment => expectedAssessment === args.options.expectedAssessment)) {
+            return `${args.options.expectedAssessment} is not an allowed expected assessment. Allowed expected assessments are ${this.allowedExpectedAssessments.join('|')}`;
+        }
+        if (!this.allowedCategories.some(category => category === args.options.category)) {
+            return `${args.options.category} is not an allowed category. Allowed categories are ${this.allowedCategories.join('|')}`;
+        }
+        if (args.options.path && !fs.existsSync(args.options.path)) {
+            return `File '${args.options.path}' not found. Please provide a valid path to the file.`;
+        }
+        return true;
+    });
+}, _PurviewThreatAssessmentAddCommand_initOptionSets = function _PurviewThreatAssessmentAddCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['path'],
+        runsWhen: (args) => {
+            return args.options.type === 'file';
+        }
+    }, {
+        options: ['url'],
+        runsWhen: (args) => {
+            return args.options.type === 'url';
+        }
+    });
+};
+export default new PurviewThreatAssessmentAddCommand();
+//# sourceMappingURL=threatassessment-add.js.map

package/dist/m365/purview/commands/threatassessment/threatassessment-list.js

@@ -0,0 +1,104 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PurviewThreatAssessmentListCommand_instances, _a, _PurviewThreatAssessmentListCommand_initTelemetry, _PurviewThreatAssessmentListCommand_initOptions, _PurviewThreatAssessmentListCommand_initValidators;
+import { odata } from '../../../../utils/odata.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class PurviewThreatAssessmentListCommand extends GraphCommand {
+    get name() {
+        return commands.THREATASSESSMENT_LIST;
+    }
+    get description() {
+        return 'Get a list of threat assessments';
+    }
+    defaultProperties() {
+        return ['id', 'type', 'category'];
+    }
+    constructor() {
+        super();
+        _PurviewThreatAssessmentListCommand_instances.add(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentListCommand_instances, "m", _PurviewThreatAssessmentListCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentListCommand_instances, "m", _PurviewThreatAssessmentListCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentListCommand_instances, "m", _PurviewThreatAssessmentListCommand_initValidators).call(this);
+    }
+    async commandAction(logger, args) {
+        if (this.verbose) {
+            logger.logToStderr('Retrieving a list of threat assessments');
+        }
+        try {
+            const filter = this.getFilterQuery(args.options);
+            const items = await odata.getAllItems(`${this.resource}/v1.0/informationProtection/threatAssessmentRequests${filter}`, 'minimal');
+            let itemsToReturn = [];
+            switch (args.options.type) {
+                case 'mail':
+                    itemsToReturn = items.filter(item => item['@odata.type'] === '#microsoft.graph.mailAssessmentRequest');
+                    break;
+                case 'emailFile':
+                    itemsToReturn = items.filter(item => item['@odata.type'] === '#microsoft.graph.emailFileAssessmentRequest');
+                    break;
+                default:
+                    itemsToReturn = items;
+                    break;
+            }
+            for (const item of itemsToReturn) {
+                item['type'] = this.getConvertedType(item['@odata.type']);
+                delete item['@odata.type'];
+            }
+            await logger.log(itemsToReturn);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    // Content type is not equal to type. 
+    // Threat assessments of type emailFile have contentType mail as well.
+    // This function gets the correct filter URL to be able to query the least amount of data
+    getFilterQuery(options) {
+        if (options.type === undefined) {
+            return '';
+        }
+        if (options.type === 'emailFile') {
+            return `?$filter=contentType eq 'mail'`;
+        }
+        return `?$filter=contentType eq '${options.type}'`;
+    }
+    getConvertedType(type) {
+        switch (type) {
+            case '#microsoft.graph.mailAssessmentRequest':
+                return 'mail';
+            case '#microsoft.graph.fileAssessmentRequest':
+                return 'file';
+            case '#microsoft.graph.emailFileAssessmentRequest':
+                return 'emailFile';
+            case '#microsoft.graph.urlAssessmentRequest':
+                return 'url';
+            default:
+                return 'Unknown';
+        }
+    }
+}
+_a = PurviewThreatAssessmentListCommand, _PurviewThreatAssessmentListCommand_instances = new WeakSet(), _PurviewThreatAssessmentListCommand_initTelemetry = function _PurviewThreatAssessmentListCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            type: typeof args.options.type !== 'undefined'
+        });
+    });
+}, _PurviewThreatAssessmentListCommand_initOptions = function _PurviewThreatAssessmentListCommand_initOptions() {
+    this.options.unshift({
+        option: '-t, --type [type]',
+        autocomplete: _a.allowedTypes
+    });
+}, _PurviewThreatAssessmentListCommand_initValidators = function _PurviewThreatAssessmentListCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.type && _a.allowedTypes.indexOf(args.options.type) < 0) {
+            return `${args.options.type} is not a valid type. Allowed values are ${_a.allowedTypes.join(', ')}`;
+        }
+        return true;
+    });
+};
+PurviewThreatAssessmentListCommand.allowedTypes = ['mail', 'file', 'emailFile', 'url'];
+export default new PurviewThreatAssessmentListCommand();
+//# sourceMappingURL=threatassessment-list.js.map

package/dist/m365/purview/commands.js

@@ -18,6 +18,8 @@ export default {
     SENSITIVITYLABEL_GET: `${prefix} sensitivitylabel get`,
     SENSITIVITYLABEL_LIST: `${prefix} sensitivitylabel list`,
     SENSITIVITYLABEL_POLICYSETTINGS_LIST: `${prefix} sensitivitylabel policysettings list`,
-    THREATASSESSMENT_GET: `${prefix} threatassessment get`
+    THREATASSESSMENT_ADD: `${prefix} threatassessment add`,
+    THREATASSESSMENT_GET: `${prefix} threatassessment get`,
+    THREATASSESSMENT_LIST: `${prefix} threatassessment list`
 };
 //# sourceMappingURL=commands.js.map

package/dist/m365/spfx/commands/project/DeployWorkflow.js

@@ -53,4 +53,115 @@ export const workflow = {
         }
     }
 };
+export const pipeline = {
+    name: "Deploy Solution",
+    trigger: {
+        branches: {
+            include: [
+                "main"
+            ]
+        }
+    },
+    pool: {
+        vmImage: "ubuntu-latest"
+    },
+    variables: [
+        {
+            name: "CertificateBase64Encoded",
+            value: ""
+        },
+        {
+            name: "CertificateSecureFileId",
+            value: ""
+        },
+        {
+            name: "CertificatePassword",
+            value: ""
+        },
+        {
+            name: "EntraAppId",
+            value: ""
+        },
+        {
+            name: "UserName",
+            value: ""
+        },
+        {
+            name: "Password",
+            value: ""
+        },
+        {
+            name: "TenantId",
+            value: ""
+        },
+        {
+            name: "SharePointBaseUrl",
+            value: ""
+        },
+        {
+            name: "PackageName",
+            value: ""
+        },
+        {
+            name: "SiteAppCatalogUrl",
+            value: ""
+        }
+    ],
+    stages: [
+        {
+            stage: "Build_and_Deploy",
+            jobs: [
+                {
+                    job: "Build_and_Deploy",
+                    steps: [
+                        {
+                            task: "NodeTool@0",
+                            displayName: "Use Node.js",
+                            inputs: {
+                                versionSpec: "18.x"
+                            }
+                        },
+                        {
+                            task: "Npm@1",
+                            displayName: "Run npm install",
+                            inputs: {
+                                command: "install"
+                            }
+                        },
+                        {
+                            task: "Gulp@0",
+                            displayName: "Gulp bundle",
+                            inputs: {
+                                gulpFile: "./gulpfile.js",
+                                targets: "bundle",
+                                arguments: "--ship"
+                            }
+                        },
+                        {
+                            task: "Gulp@0",
+                            displayName: "Gulp package",
+                            inputs: {
+                                targets: "package-solution",
+                                arguments: "--ship"
+                            }
+                        },
+                        {
+                            task: "Npm@1",
+                            displayName: "Install CLI for Microsoft 365",
+                            inputs: {
+                                command: "custom",
+                                verbose: false,
+                                customCommand: "install -g @pnp/cli-microsoft365"
+                            }
+                        },
+                        {
+                            script: "\n{{login}} \nm365 spo set --url '$(SharePointBaseUrl)' \n{{addApp}} \n{{deploy}}\n",
+                            displayName: "CLI for Microsoft 365 Deploy App"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+};
 //# sourceMappingURL=DeployWorkflow.js.map

package/dist/m365/spfx/commands/project/project-azuredevops-pipeline-add.js

@@ -0,0 +1,183 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SpfxProjectAzureDevOpsPipelineAddCommand_instances, _a, _SpfxProjectAzureDevOpsPipelineAddCommand_initTelemetry, _SpfxProjectAzureDevOpsPipelineAddCommand_initOptions, _SpfxProjectAzureDevOpsPipelineAddCommand_initValidators;
+import fs from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import { CommandError } from '../../../../Command.js';
+import commands from '../../commands.js';
+import { BaseProjectCommand } from './base-project-command.js';
+import { validation } from '../../../../utils/validation.js';
+import { pipeline } from './DeployWorkflow.js';
+import { fsUtil } from '../../../../utils/fsUtil.js';
+import { parse } from 'semver';
+class SpfxProjectAzureDevOpsPipelineAddCommand extends BaseProjectCommand {
+    get name() {
+        return commands.PROJECT_AZUREDEVOPS_PIPELINE_ADD;
+    }
+    get description() {
+        return 'Adds a Azure DevOps Pipeline for a SharePoint Framework project.';
+    }
+    constructor() {
+        super();
+        _SpfxProjectAzureDevOpsPipelineAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpfxProjectAzureDevOpsPipelineAddCommand_instances, "m", _SpfxProjectAzureDevOpsPipelineAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpfxProjectAzureDevOpsPipelineAddCommand_instances, "m", _SpfxProjectAzureDevOpsPipelineAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpfxProjectAzureDevOpsPipelineAddCommand_instances, "m", _SpfxProjectAzureDevOpsPipelineAddCommand_initValidators).call(this);
+    }
+    async commandAction(logger, args) {
+        this.projectRootPath = this.getProjectRoot(process.cwd());
+        if (this.projectRootPath === null) {
+            throw new CommandError(`Couldn't find project root folder`, _a.ERROR_NO_PROJECT_ROOT_FOLDER);
+        }
+        const solutionPackageJsonFile = path.join(this.projectRootPath, 'package.json');
+        const packageJson = fs.readFileSync(solutionPackageJsonFile, 'utf-8');
+        const solutionName = JSON.parse(packageJson).name;
+        if (this.debug) {
+            logger.logToStderr(`Adding Azure DevOps pipeline in the current SPFx project`);
+        }
+        try {
+            this.updatePipeline(solutionName, pipeline, args.options);
+            this.savePipeline(pipeline);
+        }
+        catch (error) {
+            throw new CommandError(error);
+        }
+    }
+    savePipeline(pipeline) {
+        const azureDevOpsPath = path.join(this.projectRootPath, '.azuredevops');
+        fsUtil.ensureDirectory(azureDevOpsPath);
+        const pipelinesPath = path.join(azureDevOpsPath, 'pipelines');
+        fsUtil.ensureDirectory(pipelinesPath);
+        const pipelineFile = path.join(pipelinesPath, 'deploy-spfx-solution.yml');
+        fs.writeFileSync(path.resolve(pipelineFile), yaml.stringify(pipeline), 'utf-8');
+    }
+    updatePipeline(solutionName, pipeline, options) {
+        if (options.name) {
+            pipeline.name = options.name;
+        }
+        else {
+            delete pipeline.name;
+        }
+        if (options.branchName) {
+            pipeline.trigger.branches.include[0] = options.branchName;
+        }
+        const version = this.getProjectVersion();
+        if (!version) {
+            throw `Unable to determine the version of the current SharePoint Framework project`;
+        }
+        const minorVersion = parse(version)?.minor;
+        if (minorVersion === undefined) {
+            throw `Unable to determine the minor version of the current SharePoint Framework project`;
+        }
+        if (minorVersion < 18) {
+            const node = this.getNodeAction(pipeline);
+            if (node.inputs) {
+                node.inputs.versionSpec = '16.x';
+            }
+        }
+        const script = this.getScriptAction(pipeline);
+        if (script.script) {
+            if (options.loginMethod === 'user') {
+                script.script = script.script.replace(`{{login}}`, `m365 login --authType password --userName '$(UserName)' --password '$(Password)'`);
+                pipeline.variables = pipeline.variables.filter(v => v.name !== 'CertificateBase64Encoded' &&
+                    v.name !== 'CertificateSecureFileId' &&
+                    v.name !== 'CertificatePassword' &&
+                    v.name !== 'EntraAppId' &&
+                    v.name !== 'TenantId');
+            }
+            else {
+                script.script = script.script.replace(`{{login}}`, `m365 login --authType certificate --certificateBase64Encoded '$(CertificateBase64Encoded)' --password '$(CertificatePassword)' --appId '$(EntraAppId)' --tenant '$(TenantId)'`);
+                pipeline.variables = pipeline.variables.filter(v => v.name !== 'UserName' &&
+                    v.name !== 'Password');
+            }
+            if (options.scope === 'sitecollection') {
+                script.script = script.script.replace(`{{deploy}}`, `m365 spo app deploy --name '$(PackageName)' --appCatalogScope sitecollection --appCatalogUrl '$(SiteAppCatalogUrl)'`);
+                script.script = script.script.replace(`{{addApp}}`, `m365 spo app add --filePath '$(Build.SourcesDirectory)/sharepoint/solution/$(PackageName)' --appCatalogScope sitecollection --appCatalogUrl '$(SiteAppCatalogUrl)' --overwrite`);
+                this.assignPipelineVariables(pipeline, 'SiteAppCatalogUrl', options.siteUrl);
+            }
+            else {
+                script.script = script.script.replace(`{{deploy}}`, `m365 spo app deploy --name '$(PackageName)' --appCatalogScope 'tenant'`);
+                script.script = script.script.replace(`{{addApp}}`, `m365 spo app add --filePath '$(Build.SourcesDirectory)/sharepoint/solution/$(PackageName)' --overwrite`);
+                pipeline.variables = pipeline.variables.filter(v => v.name !== 'SiteAppCatalogUrl');
+            }
+            if (solutionName) {
+                this.assignPipelineVariables(pipeline, 'PackageName', `${solutionName}.sppkg`);
+            }
+            if (options.skipFeatureDeployment) {
+                script.script = script.script.replace(`m365 spo app deploy `, `m365 spo app deploy --skipFeatureDeployment `);
+            }
+        }
+    }
+    assignPipelineVariables(pipeline, variableName, newVariableValue) {
+        const variable = pipeline.variables.find(v => v.name === variableName);
+        if (variable) {
+            variable.value = newVariableValue;
+        }
+    }
+    getScriptAction(pipeline) {
+        const steps = this.getPipelineSteps(pipeline);
+        return steps.find(step => step.script);
+    }
+    getNodeAction(pipeline) {
+        const steps = this.getPipelineSteps(pipeline);
+        return steps.find(step => step.task && step.task.indexOf('NodeTool') >= 0);
+    }
+    getPipelineSteps(pipeline) {
+        return pipeline.stages[0].jobs[0].steps;
+    }
+}
+_a = SpfxProjectAzureDevOpsPipelineAddCommand, _SpfxProjectAzureDevOpsPipelineAddCommand_instances = new WeakSet(), _SpfxProjectAzureDevOpsPipelineAddCommand_initTelemetry = function _SpfxProjectAzureDevOpsPipelineAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            name: typeof args.options.name !== 'undefined',
+            branchName: typeof args.options.branchName !== 'undefined',
+            loginMethod: typeof args.options.loginMethod !== 'undefined',
+            scope: typeof args.options.scope !== 'undefined',
+            skipFeatureDeployment: !!args.options.skipFeatureDeployment
+        });
+    });
+}, _SpfxProjectAzureDevOpsPipelineAddCommand_initOptions = function _SpfxProjectAzureDevOpsPipelineAddCommand_initOptions() {
+    this.options.unshift({
+        option: '-n, --name [name]'
+    }, {
+        option: '-b, --branchName [branchName]'
+    }, {
+        option: '-l, --loginMethod [loginMethod]',
+        autocomplete: _a.loginMethod
+    }, {
+        option: '-s, --scope [scope]',
+        autocomplete: _a.scope
+    }, {
+        option: '-u, --siteUrl [siteUrl]'
+    }, {
+        option: '--skipFeatureDeployment'
+    });
+}, _SpfxProjectAzureDevOpsPipelineAddCommand_initValidators = function _SpfxProjectAzureDevOpsPipelineAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.scope && args.options.scope === 'sitecollection') {
+            if (!args.options.siteUrl) {
+                return `siteUrl option has to be defined when scope set to ${args.options.scope}`;
+            }
+            const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.siteUrl);
+            if (isValidSharePointUrl !== true) {
+                return isValidSharePointUrl;
+            }
+        }
+        if (args.options.loginMethod && _a.loginMethod.indexOf(args.options.loginMethod) < 0) {
+            return `${args.options.loginMethod} is not a valid login method. Allowed values are ${_a.loginMethod.join(', ')}`;
+        }
+        if (args.options.scope && _a.scope.indexOf(args.options.scope) < 0) {
+            return `${args.options.scope} is not a valid scope. Allowed values are ${_a.scope.join(', ')}`;
+        }
+        return true;
+    });
+};
+SpfxProjectAzureDevOpsPipelineAddCommand.loginMethod = ['application', 'user'];
+SpfxProjectAzureDevOpsPipelineAddCommand.scope = ['tenant', 'sitecollection'];
+SpfxProjectAzureDevOpsPipelineAddCommand.ERROR_NO_PROJECT_ROOT_FOLDER = 1;
+export default new SpfxProjectAzureDevOpsPipelineAddCommand();
+//# sourceMappingURL=project-azuredevops-pipeline-add.js.map

package/dist/m365/spfx/commands/project/project-azuredevops-pipeline-model.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=project-azuredevops-pipeline-model.js.map

package/dist/m365/spfx/commands/project/project-github-workflow-add.js

@@ -13,6 +13,7 @@ import { validation } from '../../../../utils/validation.js';
 import commands from '../../commands.js';
 import { workflow } from './DeployWorkflow.js';
 import { BaseProjectCommand } from './base-project-command.js';
+import { parse } from 'semver';
 class SpfxProjectGithubWorkflowAddCommand extends BaseProjectCommand {
     get name() {
         return commands.PROJECT_GITHUB_WORKFLOW_ADD;
@@ -67,10 +68,8 @@ class SpfxProjectGithubWorkflowAddCommand extends BaseProjectCommand {
         if (!version) {
             throw `Unable to determine the version of the current SharePoint Framework project`;
         }
-        const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-        const minorVersionString = match ? match[2] : null;
-        const minorVersion = minorVersionString ? Number(minorVersionString) : null;
-        if (minorVersion === null || isNaN(minorVersion)) {
+        const minorVersion = parse(version)?.minor;
+        if (minorVersion === undefined) {
             throw `Unable to determine the minor version of the current SharePoint Framework project`;
         }
         if (minorVersion < 18) {

package/dist/m365/spfx/commands.js

@@ -2,6 +2,7 @@ const prefix = 'spfx';
 export default {
     DOCTOR: `${prefix} doctor`,
     PACKAGE_GENERATE: `${prefix} package generate`,
+    PROJECT_AZUREDEVOPS_PIPELINE_ADD: `${prefix} project azuredevops pipeline add`,
     PROJECT_DOCTOR: `${prefix} project doctor`,
     PROJECT_EXTERNALIZE: `${prefix} project externalize`,
     PROJECT_GITHUB_WORKFLOW_ADD: `${prefix} project github workflow add`,