Deploy with the Function CLI if it is installed (#4630)

nturinski · web-flow · commit 0971f2a89e2d · 2025-08-07T11:04:23.000-07:00
* Fix template version file null/undefined error Fixes #4599 - Cannot read properties of undefined (reading 'trim') when backup template version file read returns null/undefined. Added null check before calling toString().trim() on the file content to provide a more actionable error message when backup version files are missing or empty. * Deploy with Func CLI * Fix line break * Delete .github/copilot-instructions.md * Delete example-usage.md * Update TemplateProviderBase.ts * Account for deployment slots
diff --git a/src/commands/deploy/DeployFunctionCoreToolsStep.ts b/src/commands/deploy/DeployFunctionCoreToolsStep.ts
@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { type InnerDeployContext } from "@microsoft/vscode-azext-azureappservice";
+import { ActivityChildItem, ActivityChildType, activityFailContext, activityFailIcon, activityProgressContext, activityProgressIcon, activitySuccessContext, activitySuccessIcon, AzureWizardExecuteStep, createContextValue, randomUtils, type ExecuteActivityOutput } from "@microsoft/vscode-azext-utils";
+import { l10n, ThemeIcon, TreeItemCollapsibleState, type Progress } from "vscode";
+import { ext } from "../../extensionVariables";
+import { cpUtils } from "../../utils/cpUtils";
+
+export class DeployFunctionCoreToolsStep extends AzureWizardExecuteStep<InnerDeployContext> {
+    stepName: string;
+    private _childId: string = randomUtils.getRandomHexString(8); // create child id in class to make it idempotent
+    private _command: { title: string; command: string } = {
+        title: '',
+        command: ext.prefix + '.showOutputChannel'
+    };
+    public createSuccessOutput(context: InnerDeployContext): ExecuteActivityOutput {
+        const label = l10n.t('Publish "{0}" to "{1}" with Function Core Tools', context.originalDeployFsPath, context.site.fullName);
+        return {
+            item: new ActivityChildItem({
+                contextValue: createContextValue([activitySuccessContext, context.site.id]),
+                label,
+                iconPath: activitySuccessIcon,
+                activityType: ActivityChildType.Success,
+
+            })
+        };
+    }
+    public createProgressOutput(context: InnerDeployContext): ExecuteActivityOutput {
+        const label = l10n.t('Publish "{0}" to "{1}" with Function Core Tools', context.originalDeployFsPath, context.site.fullName);
+        const item = new ActivityChildItem({
+            contextValue: createContextValue([activityProgressContext, context.site.id]),
+            label,
+            iconPath: activityProgressIcon,
+            activityType: ActivityChildType.Progress,
+            isParent: true,
+            initialCollapsibleState: TreeItemCollapsibleState.Expanded
+        });
+
+        item.getChildren = () => {
+            return [
+                new ActivityChildItem({
+                    label: l10n.t('Click to view output channel'),
+                    id: this._childId,
+                    command: this._command,
+                    activityType: ActivityChildType.Info,
+                    contextValue: createContextValue([activityProgressContext, 'viewOutputChannel']),
+                    iconPath: new ThemeIcon('output')
+                })
+            ];
+        };
+
+        return {
+            item
+        };
+    }
+    public createFailOutput(context: InnerDeployContext): ExecuteActivityOutput {
+        const label = l10n.t('Publish "{0}" to "{1}" with Function Core Tools', context.originalDeployFsPath, context.site.fullName);
+        const item = new ActivityChildItem({
+            contextValue: createContextValue([activityFailContext, context.site.id]),
+            label,
+            iconPath: activityFailIcon,
+            activityType: ActivityChildType.Fail,
+            isParent: true,
+            initialCollapsibleState: TreeItemCollapsibleState.Expanded
+        });
+
+        item.getChildren = () => {
+            return [
+                new ActivityChildItem({
+                    label: l10n.t('Click to view output channel'),
+                    id: this._childId,
+                    command: this._command,
+                    activityType: ActivityChildType.Info,
+                    contextValue: createContextValue([activityProgressContext, 'viewOutputChannel']),
+                    iconPath: new ThemeIcon('output')
+                })
+            ];
+        };
+
+        return {
+            item
+        };
+    }
+    public priority: number = 100;
+    public async execute(context: InnerDeployContext, progress: Progress<{ message?: string; increment?: number; }>): Promise<void> {
+        const message = l10n.t('Publishing "{0}" to "{1}" with Functiontion Core Tools...', context.originalDeployFsPath, context.site.fullName);
+        progress.report({ message });
+        context.activityAttributes = context.activityAttributes ?? { logs: [] };
+        const args = ['func', 'azure', 'functionapp', 'publish', context.site.siteName];
+        if (context.site.isSlot) {
+            // if there's no slotName, then just assume production
+            args.push('--slot', context.site.slotName ?? 'production');
+        }
+        const cmdOutput = await cpUtils.tryExecuteCommand(ext.outputChannel, context.originalDeployFsPath, args.join(' '));
+        context.activityAttributes.logs = [{ content: cmdOutput.cmdOutputIncludingStderr }];
+    }
+    public shouldExecute(_context: InnerDeployContext): boolean {
+        return true;
+    }
+}
diff --git a/src/commands/deploy/deploy.ts b/src/commands/deploy/deploy.ts
@@ -4,14 +4,15 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { type Site, type SiteConfigResource, type StringDictionary } from '@azure/arm-appservice';
-import { getDeployFsPath, getDeployNode, deploy as innerDeploy, showDeployConfirmation, type IDeployContext, type IDeployPaths, type ParsedSite } from '@microsoft/vscode-azext-azureappservice';
+import { getDeployFsPath, getDeployNode, deploy as innerDeploy, showDeployConfirmation, type IDeployContext, type IDeployPaths, type InnerDeployContext, type ParsedSite } from '@microsoft/vscode-azext-azureappservice';
 import { ResourceGroupListStep } from '@microsoft/vscode-azext-azureutils';
-import { DialogResponses, subscriptionExperience, type ExecuteActivityContext, type IActionContext, type ISubscriptionContext } from '@microsoft/vscode-azext-utils';
+import { AzureWizard, DialogResponses, subscriptionExperience, type ExecuteActivityContext, type IActionContext, type ISubscriptionContext } from '@microsoft/vscode-azext-utils';
 import { type AzureSubscription } from '@microsoft/vscode-azureresources-api';
 import type * as vscode from 'vscode';
 import { CodeAction, deploySubpathSetting, DurableBackend, hostFileName, ProjectLanguage, remoteBuildSetting, ScmType, stackUpgradeLearnMoreLink } from '../../constants';
 import { ext } from '../../extensionVariables';
 import { addLocalFuncTelemetry } from '../../funcCoreTools/getLocalFuncCoreToolsVersion';
+import { funcToolsInstalled, validateFuncCoreToolsInstalled } from '../../funcCoreTools/validateFuncCoreToolsInstalled';
 import { localize } from '../../localize';
 import { ResolvedFunctionAppResource } from '../../tree/ResolvedFunctionAppResource';
 import { type SlotTreeItem } from '../../tree/SlotTreeItem';
@@ -30,6 +31,7 @@ import { getNetheriteConnectionIfNeeded } from '../appSettings/connectionSetting
 import { getSQLConnectionIfNeeded } from '../appSettings/connectionSettings/sqlDatabase/getSQLConnection';
 import { getEolWarningMessages } from '../createFunctionApp/stacks/getStackPicks';
 import { tryGetFunctionProjectRoot } from '../createNewProject/verifyIsProject';
+import { DeployFunctionCoreToolsStep } from './DeployFunctionCoreToolsStep';
 import { getOrCreateFunctionApp } from './getOrCreateFunctionApp';
 import { getWarningsForConnectionSettings } from './getWarningsForConnectionSettings';
 import { notifyDeployComplete } from './notifyDeployComplete';
@@ -218,54 +220,81 @@ async function deploy(actionContext: IActionContext, arg1: vscode.Uri | string |
             eolWarningMessage ? stackUpgradeLearnMoreLink : undefined);
     }
 
-    await runPreDeployTask(context, context.effectiveDeployFsPath, siteConfig.scmType);
-
-    if (isZipDeploy) {
-        void validateGlobSettings(context, context.effectiveDeployFsPath);
+    let isFuncToolsInstalled: boolean = await funcToolsInstalled(context, context.workspaceFolder.uri.fsPath);
+    if (language === ProjectLanguage.Custom && !isFuncToolsInstalled) {
+        await validateFuncCoreToolsInstalled(context, localize('validateFuncCoreToolsCustom', 'The Functions Core Tools are required to deploy to a custom runtime function app.'));
+        isFuncToolsInstalled = true;
     }
 
-    if (language === ProjectLanguage.CSharp && !site.isLinux || durableStorageType) {
-        await updateWorkerProcessTo64BitIfRequired(context, siteConfig, site, language, durableStorageType);
-    }
 
-    // app settings shouldn't be checked with flex consumption plans
-    if (isZipDeploy && !isFlexConsumption) {
-        await verifyAppSettings({
-            context,
-            node,
-            projectPath: context.projectPath,
-            version,
-            language,
-            languageModel,
-            bools: { doRemoteBuild, isConsumption },
-            durableStorageType,
-            appSettings
-        });
-    }
+    if (!isFuncToolsInstalled) {
+        await runPreDeployTask(context, context.effectiveDeployFsPath, siteConfig.scmType);
+
+        if (isZipDeploy) {
+            void validateGlobSettings(context, context.effectiveDeployFsPath);
+        }
+
+        if (language === ProjectLanguage.CSharp && !site.isLinux || durableStorageType) {
+            await updateWorkerProcessTo64BitIfRequired(context, siteConfig, site, language, durableStorageType);
+        }
 
+        // app settings shouldn't be checked with flex consumption plans
+        if (isZipDeploy && !isFlexConsumption) {
+            await verifyAppSettings({
+                context,
+                node,
+                projectPath: context.projectPath,
+                version,
+                language,
+                languageModel,
+                bools: { doRemoteBuild, isConsumption },
+                durableStorageType,
+                appSettings
+            });
+        }
+    }
+    let deployedWithFuncCli = false;
     await node.runWithTemporaryDescription(
         context,
         localize('deploying', 'Deploying...'),
         async () => {
-            // Stop function app here to avoid *.jar file in use on server side.
-            // More details can be found: https://github.com/Microsoft/vscode-azurefunctions/issues/106
-            context.stopAppBeforeDeploy = language === ProjectLanguage.Java;
-
-            // preDeploy tasks are only required for zipdeploy so subpath may not exist
-            let deployFsPath: string = context.effectiveDeployFsPath;
-
-            if (!isZipDeploy && !isPathEqual(context.effectiveDeployFsPath, context.originalDeployFsPath)) {
-                deployFsPath = context.originalDeployFsPath;
-                const noSubpathWarning: string = `WARNING: Ignoring deploySubPath "${getWorkspaceSetting(deploySubpathSetting, context.originalDeployFsPath)}" for non-zip deploy.`;
-                ext.outputChannel.appendLog(noSubpathWarning);
+            // prioritize func cli deployment if installed
+            if (isFuncToolsInstalled) {
+                context.telemetry.properties.funcCoreToolsInstalled = 'true';
+                context.telemetry.properties.deployMethod = 'funccli';
+                const deployContext = Object.assign(context, await createActivityContext(), { site }) as unknown as InnerDeployContext;
+                deployContext.activityChildren = [];
+                const wizard = new AzureWizard(deployContext, {
+                    executeSteps: [new DeployFunctionCoreToolsStep()],
+                });
+
+                deployContext.activityTitle = site.isSlot
+                    ? localize('deploySlot', 'Deploy to slot "{0}"', site.fullName)
+                    : localize('deployApp', 'Deploy to app "{0}"', site.fullName);
+                await wizard.execute();
+                deployedWithFuncCli = true;
+                return;
+            } else {
+                // Stop function app here to avoid *.jar file in use on server side.
+                // More details can be found: https://github.com/Microsoft/vscode-azurefunctions/issues/106
+                context.stopAppBeforeDeploy = language === ProjectLanguage.Java;
+
+                // preDeploy tasks are only required for zipdeploy so subpath may not exist
+                let deployFsPath: string = context.effectiveDeployFsPath;
+
+                if (!isZipDeploy && !isPathEqual(context.effectiveDeployFsPath, context.originalDeployFsPath)) {
+                    deployFsPath = context.originalDeployFsPath;
+                    const noSubpathWarning: string = `WARNING: Ignoring deploySubPath "${getWorkspaceSetting(deploySubpathSetting, context.originalDeployFsPath)}" for non-zip deploy.`;
+                    ext.outputChannel.appendLog(noSubpathWarning);
+                }
+                const deployContext = Object.assign(context, await createActivityContext());
+                deployContext.activityChildren = [];
+                await innerDeploy(site, deployFsPath, deployContext);
             }
-            const deployContext = Object.assign(context, await createActivityContext());
-            deployContext.activityChildren = [];
-            await innerDeploy(site, deployFsPath, deployContext);
         }
     );
 
-    await notifyDeployComplete(context, node, context.workspaceFolder, isFlexConsumption);
+    await notifyDeployComplete(context, node, context.workspaceFolder, isFlexConsumption, deployedWithFuncCli);
 }
 
 async function updateWorkerProcessTo64BitIfRequired(context: IDeployContext, siteConfig: SiteConfigResource, site: ParsedSite, language: ProjectLanguage, durableStorageType: DurableBackend | undefined): Promise<void> {
@@ -310,3 +339,4 @@ async function validateGlobSettings(context: IActionContext, fsPath: string): Pr
         await context.ui.showWarningMessage(message, { stepName: 'globSettingRemoved' });
     }
 }
+
diff --git a/src/commands/deploy/notifyDeployComplete.ts b/src/commands/deploy/notifyDeployComplete.ts
@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { type IDeployContext } from '@microsoft/vscode-azext-azureappservice';
 import { callWithTelemetryAndErrorHandling, type AzExtTreeItem, type IActionContext } from '@microsoft/vscode-azext-utils';
 import * as retry from 'p-retry';
 import { window, type MessageItem, type WorkspaceFolder } from 'vscode';
@@ -16,7 +17,7 @@ import { uploadAppSettings } from '../appSettings/uploadAppSettings';
 import { startStreamingLogs } from '../logstream/startStreamingLogs';
 import { hasRemoteEventGridBlobTrigger, promptForEventGrid } from './promptForEventGrid';
 
-export async function notifyDeployComplete(context: IActionContext, node: SlotTreeItem, workspaceFolder: WorkspaceFolder, isFlexConsumption?: boolean): Promise<void> {
+export async function notifyDeployComplete(context: IDeployContext, node: SlotTreeItem, workspaceFolder: WorkspaceFolder, isFlexConsumption?: boolean, deployedWithFuncCli?: boolean): Promise<void> {
     await node.initSite(context);
     const deployComplete: string = localize('deployComplete', 'Deployment to "{0}" completed.', node.site.fullName);
     const viewOutput: MessageItem = { title: localize('viewOutput', 'View output') };
@@ -55,6 +56,10 @@ export async function notifyDeployComplete(context: IActionContext, node: SlotTr
     });
 
     try {
+        if (deployedWithFuncCli) {
+            // don't query triggers if we used the func cli to deploy
+            return;
+        }
         const retries: number = 4;
         await retry(
             async (currentAttempt: number) => {
diff --git a/src/templates/TemplateProviderBase.ts b/src/templates/TemplateProviderBase.ts
@@ -11,6 +11,7 @@ import { type IProjectWizardContext } from '../commands/createNewProject/IProjec
 import { type ProjectLanguage } from '../constants';
 import { NotImplementedError } from '../errors';
 import { ext } from '../extensionVariables';
+import { localize } from '../localize';
 import { type IBindingTemplate } from './IBindingTemplate';
 import { type FunctionTemplateBase } from './IFunctionTemplate';
 import { type ITemplates } from './ITemplates';
@@ -106,7 +107,11 @@ export abstract class TemplateProviderBase implements Disposable {
     }
 
     public async getBackupTemplateVersion(): Promise<string> {
-        return (await AzExtFsExtra.readFile(await this.getBackupVersionPath())).toString().trim();
+        const versionContent = await AzExtFsExtra.readFile(await this.getBackupVersionPath());
+        if (!versionContent) {
+            throw new Error(localize('backupVersionFileEmpty', 'Backup template version file is empty or could not be read'));
+        }
+        return versionContent.toString().trim();
     }
 
     public async updateBackupTemplateVersion(version: string): Promise<void> {
