wip garbage copilot mvp

alexweininger · alexweininger · commit ca3947306cfc · 2025-10-30T17:49:33.000-07:00
diff --git a/package.json b/package.json
@@ -149,6 +149,11 @@
                 "title": "%azureFunctions.browseWebsite%",
                 "category": "Azure Functions"
             },
+            {
+                "command": "azureFunctions.createProjectFromFunctionApp",
+                "title": "%azureFunctions.createProjectFromFunctionApp%",
+                "category": "Azure Functions"
+            },
             {
                 "command": "azureFunctions.configureDeploymentSource",
                 "title": "%azureFunctions.configureDeploymentSource%",
@@ -211,6 +216,18 @@
                 "category": "Azure Functions",
                 "enablement": "!virtualWorkspace"
             },
+            {
+                "command": "azureFunctions.testExternalRuntime",
+                "title": "Test External Runtime Configuration",
+                "category": "Azure Functions (Test)",
+                "enablement": "!virtualWorkspace"
+            },
+            {
+                "command": "azureFunctions.testTypeScriptExternalRuntime",
+                "title": "Test TypeScript External Runtime",
+                "category": "Azure Functions (Test)",
+                "enablement": "!virtualWorkspace"
+            },
             {
                 "command": "azureFunctions.createSlot",
                 "title": "%azureFunctions.createSlot%",
diff --git a/package.nls.json b/package.nls.json
@@ -13,6 +13,7 @@
     "azureFunctions.assignManagedIdentity": "Assign Managed Identity to Function App...",
     "azureFunctions.unassignManagedIdentity": "Unassign Managed Identity from Function App...",
     "azureFunctions.browseWebsite": "Browse Website",
+    "azureFunctions.createProjectFromFunctionApp": "Create Project from Function App...",
     "azureFunctions.configureDeploymentSource": "Configure Deployment Source...",
     "azureFunctions.connectToGitHub": "Connect to GitHub Repository...",
     "azureFunctions.copyFunctionUrl": "Copy Function Url",
diff --git a/src/commands/createNewProject/IProjectWizardContext.ts b/src/commands/createNewProject/IProjectWizardContext.ts
@@ -31,6 +31,12 @@ export interface IProjectWizardContext extends IActionContext {
     targetFramework?: string | string[];
 
     containerizedProject?: boolean;
+
+    // External runtime configuration from Azure APIs
+    externalRuntimeConfig?: {
+        runtimeName: string;
+        runtimeVersion: string;
+    };
 }
 
 export type OpenBehavior = 'AddToWorkspace' | 'OpenInNewWindow' | 'OpenInCurrentWindow' | 'AlreadyOpen' | 'DontOpen';
diff --git a/src/commands/createNewProject/NewProjectLanguageStep.ts b/src/commands/createNewProject/NewProjectLanguageStep.ts
@@ -8,6 +8,7 @@ import { type QuickPickOptions } from 'vscode';
 import { ProjectLanguage, nodeDefaultModelVersion, nodeLearnMoreLink, nodeModels, pythonDefaultModelVersion, pythonLearnMoreLink, pythonModels } from '../../constants';
 import { localize } from '../../localize';
 import { TemplateSchemaVersion } from '../../templates/TemplateProviderBase';
+import { getRuntimeMapping } from '../../utils/externalRuntimeUtils';
 import { nonNullProp } from '../../utils/nonNull';
 import { openUrl } from '../../utils/openUrl';
 import { FunctionListStep } from '../createFunction/FunctionListStep';
@@ -38,6 +39,19 @@ export class NewProjectLanguageStep extends AzureWizardPromptStep<IProjectWizard
     }
 
     public async prompt(context: IProjectWizardContext): Promise<void> {
+        if (context.externalRuntimeConfig) {
+            // Auto-set language based on external runtime config
+            const mapping = getRuntimeMapping(context.externalRuntimeConfig.runtimeName, context.externalRuntimeConfig.runtimeVersion);
+            if (mapping) {
+                context.language = mapping.language as ProjectLanguage;
+                context.languageModel = mapping.languageModel;
+                if (mapping.targetFramework) {
+                    context.targetFramework = [mapping.targetFramework];
+                }
+                return;
+            }
+        }
+
         // Only display 'supported' languages that can be debugged in VS Code
         let languagePicks: IAzureQuickPickItem<{ language: ProjectLanguage, model?: number } | undefined>[] = [
             { label: ProjectLanguage.JavaScript, data: { language: ProjectLanguage.JavaScript } },
diff --git a/src/commands/createNewProject/createNewProject.ts b/src/commands/createNewProject/createNewProject.ts
@@ -47,7 +47,12 @@ export async function createNewProjectFromCommand(
     });
 }
 
-export async function createNewProjectInternal(context: IActionContext, options: api.ICreateFunctionOptions): Promise<void> {
+export async function createNewProjectInternal(context: IActionContext, options: api.ICreateFunctionOptions & {
+    externalRuntimeConfig?: {
+        runtimeName: string;
+        runtimeVersion: string;
+    };
+}): Promise<void> {
     addLocalFuncTelemetry(context, undefined);
 
     const language: ProjectLanguage | undefined = <ProjectLanguage>options.language || getGlobalSetting(projectLanguageSetting);
@@ -59,7 +64,8 @@ export async function createNewProjectInternal(context: IActionContext, options:
         {
             language,
             version: tryParseFuncVersion(version),
-            projectTemplateKey
+            projectTemplateKey,
+            externalRuntimeConfig: options.externalRuntimeConfig
         },
         await createActivityContext()
     );
diff --git a/src/commands/createNewProject/dotnetSteps/DotnetRuntimeStep.ts b/src/commands/createNewProject/dotnetSteps/DotnetRuntimeStep.ts
@@ -21,8 +21,26 @@ export class DotnetRuntimeStep extends AzureWizardPromptStep<IProjectWizardConte
             const filteredRuntimes = runtimes.filter(runtime => context.targetFramework?.includes(runtime.targetFramework));
             let workerRuntime: cliFeedUtils.IWorkerRuntime | undefined = undefined;
             if (filteredRuntimes.length > 1) {
-                const placeHolder: string = localize('selectWorkerRuntime', 'Select a .NET runtime');
-                workerRuntime = (await context.ui.showQuickPick(new DotnetRuntimeStep().getPicks(context, filteredRuntimes), { placeHolder })).data;
+                if (context.externalRuntimeConfig) {
+                    // Separate filtered runtimes by isolated and non-isolated
+                    const isolatedRuntimes = filteredRuntimes.filter(r => r.capabilities.includes('isolated'));
+                    const inProcessRuntimes = filteredRuntimes.filter(r => !r.capabilities.includes('isolated'));
+
+
+                    // Pick runtime based on the expected linuxFxVersion
+                    const isIsolatedRequest = context.externalRuntimeConfig.runtimeName.toLowerCase().includes('isolated');
+                    if (isIsolatedRequest && isolatedRuntimes.length > 0) {
+                        workerRuntime = isolatedRuntimes[0];
+                    } else if (!isIsolatedRequest && inProcessRuntimes.length > 0) {
+                        workerRuntime = inProcessRuntimes[0];
+                    } else {
+                        // Fallback: prefer isolated if available, otherwise use first available
+                        workerRuntime = isolatedRuntimes[0] || inProcessRuntimes[0] || filteredRuntimes[0];
+                    }
+                } else {
+                    const placeHolder: string = localize('selectWorkerRuntime', 'Select a .NET runtime');
+                    workerRuntime = (await context.ui.showQuickPick(new DotnetRuntimeStep().getPicks(context, filteredRuntimes), { placeHolder })).data;
+                }
             } else if (filteredRuntimes.length === 1) {
                 workerRuntime = filteredRuntimes[0];
             }
@@ -39,6 +57,26 @@ export class DotnetRuntimeStep extends AzureWizardPromptStep<IProjectWizardConte
     }
 
     public async prompt(context: IProjectWizardContext): Promise<void> {
+        if (context.externalRuntimeConfig) {
+            // Auto-select runtime based on external config using linuxFxVersion format
+            const runtimes = await getRuntimes(context);
+            const runtimeName = context.externalRuntimeConfig.runtimeName.toLowerCase();
+            const runtimeVersion = context.externalRuntimeConfig.runtimeVersion;
+
+            // Construct the expected linuxFxVersion string
+            const expectedLinuxFxVersion = `${runtimeName}|${runtimeVersion}`.toLowerCase();
+
+            // Find runtime that matches the expected linuxFxVersion pattern
+            const isIsolatedRequest = expectedLinuxFxVersion.includes('isolated');
+            const result = runtimes.find(r => {
+                const runtimeIsIsolated = r.displayInfo.displayName.toLowerCase().includes('isolated');
+                return runtimeIsIsolated === isIsolatedRequest;
+            }) || runtimes[0];
+
+            setWorkerRuntime(context, result);
+            return;
+        }
+
         const placeHolder: string = localize('selectWorkerRuntime', 'Select a .NET runtime');
         let result: cliFeedUtils.IWorkerRuntime | undefined;
         while (true) {
@@ -54,7 +92,8 @@ export class DotnetRuntimeStep extends AzureWizardPromptStep<IProjectWizardConte
     }
 
     public shouldPrompt(context: IProjectWizardContext): boolean {
-        return !context.workerRuntime;
+        // Skip prompting if external runtime configuration is provided or worker runtime already set
+        return !context.workerRuntime && !context.externalRuntimeConfig;
     }
 
     private async getPicks(context: IProjectWizardContext, runtimes?: cliFeedUtils.IWorkerRuntime[]): Promise<IAzureQuickPickItem<cliFeedUtils.IWorkerRuntime | undefined>[]> {
diff --git a/src/commands/createNewProject/javaSteps/JavaVersionStep.ts b/src/commands/createNewProject/javaSteps/JavaVersionStep.ts
@@ -54,6 +54,7 @@ export class JavaVersionStep extends AzureWizardPromptStep<IJavaProjectWizardCon
     }
 
     public shouldPrompt(context: IJavaProjectWizardContext): boolean {
-        return !context.javaVersion;
+        // Skip prompting if external runtime configuration is provided
+        return !context.javaVersion && !context.externalRuntimeConfig;
     }
 }
diff --git a/src/commands/createNewProject/pythonSteps/IPythonVenvWizardContext.ts b/src/commands/createNewProject/pythonSteps/IPythonVenvWizardContext.ts
@@ -14,4 +14,10 @@ export interface IPythonVenvWizardContext extends IActionContext {
     useExistingVenv?: boolean;
     venvName?: string;
     suppressSkipVenv?: boolean;
+
+    // External runtime configuration from Azure APIs
+    externalRuntimeConfig?: {
+        runtimeName: string;
+        runtimeVersion: string;
+    };
 }
diff --git a/src/commands/createNewProject/pythonSteps/PythonAliasListStep.ts b/src/commands/createNewProject/pythonSteps/PythonAliasListStep.ts
@@ -4,6 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { AzureWizardPromptStep, type IAzureQuickPickItem, type IWizardOptions } from "@microsoft/vscode-azext-utils";
+import { gt, satisfies } from "semver";
 import { localize } from "../../../localize";
 import { getGlobalSetting } from "../../../vsCodeConfig/settings";
 import { EnterPythonAliasStep } from "./EnterPythonAliasStep";
@@ -14,6 +15,21 @@ export class PythonAliasListStep extends AzureWizardPromptStep<IPythonVenvWizard
     public hideStepCount: boolean = true;
 
     public async prompt(context: IPythonVenvWizardContext): Promise<void> {
+
+
+        if (context.externalRuntimeConfig) {
+            const installedVersions = await getInstalledPythonVersions(context);
+            const matchingVersion = findBestMatchingVersion(context.externalRuntimeConfig.runtimeVersion, installedVersions);
+
+            if (matchingVersion) {
+                context.pythonAlias = matchingVersion.alias;
+                context.telemetry.properties.pythonAliasBehavior = 'externalRuntimeConfigMatch';
+                return;
+            } else {
+                return;
+            }
+        }
+
         const placeHolder: string = localize('selectAlias', 'Select a Python interpreter to create a virtual environment');
         const result: string | boolean = (await context.ui.showQuickPick(getPicks(context), { placeHolder })).data;
         if (typeof result === 'string') {
@@ -26,6 +42,7 @@ export class PythonAliasListStep extends AzureWizardPromptStep<IPythonVenvWizard
     }
 
     public shouldPrompt(context: IPythonVenvWizardContext): boolean {
+        // Skip prompting if external runtime configuration is provided
         return !context.useExistingVenv && !context.pythonAlias;
     }
 
@@ -55,7 +72,43 @@ async function getPicks(context: IPythonVenvWizardContext): Promise<IAzureQuickP
     }
 
     const picks: IAzureQuickPickItem<string | boolean>[] = [];
-    const versions: string[] = [];
+    const pythonVersions = await getInstalledPythonVersions(context);
+    pythonVersions.forEach(pv => picks.push({
+        label: pv.alias,
+        description: pv.version,
+        data: pv.alias
+    }));
+
+    picks.push({ label: localize('enterAlias', '$(keyboard) Manually enter Python interpreter or full path'), data: true });
+
+    if (!context.suppressSkipVenv) {
+        picks.push({ label: localize('skipVenv', '$(circle-slash) Skip virtual environment'), data: false, suppressPersistence: true });
+    }
+
+    return picks;
+}
+
+interface InstalledPythonVersion {
+    alias: string;
+    version: string;
+}
+
+// use this method to preselect python version if runtime version is provided externally
+
+async function getInstalledPythonVersions(context: IPythonVenvWizardContext): Promise<InstalledPythonVersion[]> {
+    const supportedVersions: string[] = await getSupportedPythonVersions(context, context.version);
+
+    const aliasesToTry: string[] = ['python', 'python3', 'py'];
+    for (const version of supportedVersions) {
+        aliasesToTry.push(`python${version}`, `py -${version}`);
+    }
+
+    const globalPythonPathSetting: string | undefined = getGlobalSetting('pythonPath', 'python');
+    if (globalPythonPathSetting) {
+        aliasesToTry.unshift(globalPythonPathSetting);
+    }
+
+    const versions: InstalledPythonVersion[] = [];
     for (const alias of aliasesToTry) {
         let version: string;
         try {
@@ -64,23 +117,27 @@ async function getPicks(context: IPythonVenvWizardContext): Promise<IAzureQuickP
             continue;
         }
 
-        if (isSupportedPythonVersion(supportedVersions, version) && !versions.some(v => v === version)) {
-            picks.push({
-                label: alias,
-                description: version,
-                data: alias
+        if (isSupportedPythonVersion(supportedVersions, version) && !versions.some(v => v.version === version)) {
+            versions.push({
+                alias,
+                version,
             });
-            versions.push(version);
         }
     }
 
     context.telemetry.properties.detectedPythonVersions = versions.join(',');
+    return versions;
+}
 
-    picks.push({ label: localize('enterAlias', '$(keyboard) Manually enter Python interpreter or full path'), data: true });
+// use semver to find a matching python version
+function findMatchingVersion(requestedVersion: string, versions: InstalledPythonVersion[]): InstalledPythonVersion | undefined {
+    return versions.find(v => satisfies(v.version, requestedVersion));
+}
 
-    if (!context.suppressSkipVenv) {
-        picks.push({ label: localize('skipVenv', '$(circle-slash) Skip virtual environment'), data: false, suppressPersistence: true });
+function findBestMatchingVersion(requestedVersion: string, versions: InstalledPythonVersion[]): InstalledPythonVersion | undefined {
+    let matchingVersion = findMatchingVersion(requestedVersion, versions);
+    if (!matchingVersion) {
+        matchingVersion = versions.reduce((prev, current) => (gt(current.version, prev.version) ? current : prev));
     }
-
-    return picks;
+    return matchingVersion;
 }
diff --git a/src/commands/initializeProjectForSlashAzure.ts b/src/commands/initializeProjectForSlashAzure.ts
@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { type IActionContext } from '@microsoft/vscode-azext-utils';
+import { getCurrentWorkspacePath, validateRuntimeParams } from '../utils/externalRuntimeUtils';
+import { type FunctionAppStackValue } from './createFunctionApp/stacks/models/FunctionAppStackModel';
+import { createNewProjectInternal } from './createNewProject/createNewProject';
+
+export type RuntimeName = FunctionAppStackValue | 'dotnet-isolated';
+
+interface InitializeProjectForSlashAzureParams {
+    id: string;
+    runtimeName: RuntimeName;
+    runtimeVersion: string;
+}
+
+/**
+ *
+ * Needs to initialize a local project based on the given function app information.
+ *
+ * @param context
+ * @param id id of the function app in Azure
+ * @param runtimeName ex: 'node', 'python', 'dotnet', etc.
+ * @param runtimeVersion ex: '18', '3.11', '8.0', etc.
+ */
+export async function initializeProjectForSlashAzure(
+    context: IActionContext,
+    params: InitializeProjectForSlashAzureParams
+): Promise<void> {
+
+    const { id, runtimeName, runtimeVersion } = params;
+
+    // Validate the runtime configuration
+    validateRuntimeParams(runtimeName, runtimeVersion);
+
+    context.telemetry.properties.externalRuntimeName = runtimeName;
+    context.telemetry.properties.externalRuntimeVersion = runtimeVersion;
+
+    // todo set id in settings as the default app to deploy to
+    console.log(id);
+
+    // Initialize the project using the existing createNewProjectInternal with external runtime config
+    await createNewProjectInternal(context, {
+        folderPath: getCurrentWorkspacePath(),
+        suppressOpenFolder: true, // Don't open folder since we're in current workspace
+        externalRuntimeConfig: {
+            runtimeName,
+            runtimeVersion
+        }
+    });
+}
diff --git a/src/commands/registerCommands.ts b/src/commands/registerCommands.ts
@@ -68,6 +68,7 @@ import { executeFunction } from './executeFunction/executeFunction';
 import { assignManagedIdentity } from './identity/assignManagedIdentity';
 import { enableSystemIdentity } from './identity/enableSystemIdentity';
 import { unassignManagedIdentity } from './identity/unassignManagedIdentity';
+import { initializeProjectForSlashAzure } from './initializeProjectForSlashAzure';
 import { initProjectForVSCode } from './initProjectForVSCode/initProjectForVSCode';
 import { startStreamingLogs } from './logstream/startStreamingLogs';
 import { stopStreamingLogs } from './logstream/stopStreamingLogs';
@@ -81,6 +82,7 @@ import { restartFunctionApp } from './restartFunctionApp';
 import { startFunctionApp } from './startFunctionApp';
 import { stopFunctionApp } from './stopFunctionApp';
 import { swapSlot } from './swapSlot';
+import { testExternalRuntimeCommand, testTypeScriptExternalRuntime } from './testExternalRuntime';
 import { disableFunction, enableFunction } from './updateDisabledState';
 import { viewProperties } from './viewProperties';
 
@@ -154,6 +156,11 @@ export function registerCommands(
     registerCommandWithTreeNodeUnwrapping('azureFunctions.enableFunction', enableFunction);
     registerCommandWithTreeNodeUnwrapping('azureFunctions.executeFunction', executeFunction);
     registerCommand('azureFunctions.initProjectForVSCode', initProjectForVSCode);
+    registerCommand('azureFunctions.initializeProjectForSlashAzure', initializeProjectForSlashAzure);
+
+    // Test commands for external runtime initialization
+    registerCommand('azureFunctions.testExternalRuntime', testExternalRuntimeCommand);
+    registerCommand('azureFunctions.testTypeScriptExternalRuntime', testTypeScriptExternalRuntime);
     registerCommandWithTreeNodeUnwrapping('azureFunctions.installOrUpdateFuncCoreTools', installOrUpdateFuncCoreTools);
     registerCommandWithTreeNodeUnwrapping('azureFunctions.openFile', openFile);
     registerCommandWithTreeNodeUnwrapping('azureFunctions.openInPortal', openDeploymentInPortal);
diff --git a/src/commands/testExternalRuntime.ts b/src/commands/testExternalRuntime.ts
diff --git a/src/constants.ts b/src/constants.ts
diff --git a/src/utils/externalRuntimeUtils.ts b/src/utils/externalRuntimeUtils.ts

Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,7 @@ export class JavaVersionStep extends AzureWizardPromptStep<IJavaProjectWizardCon`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`public shouldPrompt(context: IJavaProjectWizardContext): boolean {`
`57`		`- return !context.javaVersion;`
	`57`	`+ // Skip prompting if external runtime configuration is provided`
	`58`	`+ return !context.javaVersion && !context.externalRuntimeConfig;`
`58`	`59`	`}`
`59`	`60`	`}`