azure-functions-cli 1.0.0-beta.93 → 5.0.0-preview.5

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) .NET Foundation.  All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,156 +1,263 @@
-![Azure Functions Logo](https://raw.githubusercontent.com/Azure/azure-functions-cli/master/src/Azure.Functions.Cli/npm/assets/azure-functions-logo-color-raster.png)
-
-# Azure Functions CLI
-
-The Azure Functions CLI provides a local development experience for creating, developing, testing, running, and debugging Azure Functions.
-
-## Installing
-
-**NOTE**: This package only currently works on Windows, since the underlying Functions Host is not yet cross-platform. You can upvote this GitHub issue if you're interested in running on other platforms: [make the Azure Functions CLI cross platform](https://github.com/Azure/azure-functions-cli/issues/13).
-
-To install globally:
-
-```
-npm i -g azure-functions-cli
-```
-
-### Aliases
-
-The package sets up the following global aliases:
-
-```
-func
-azfun
-azure-functions
-```
-
-## Commands
-
-The CLI commands have the following basic structure:
-
-```
-func [context] [context] <action> [-/--options]
-```
-
-Output can be found at *%temp%\LogFiles*.
-
-### Contexts
-
-```
-azure        For Azure login and working with Function Apps on Azure
-function     For local function settings and actions
-functionapp  For local function app settings and actions
-host         For local Functions host settings and actions
-settings     For local settings for your Functions host
-```
-
-### Top-level actions
-
-```
-func init    Create a new Function App in the current folder. Initializes git repo.
-func run     Run a function directly
-```
-
-### Azure actions
-
-Actions in the "azure" context require logging in to Azure.
-
-```
-func azure
-
-Usage: func azure [context] <action> [-/--options]
-
-Contexts:
-account        For Azure account and subscriptions settings and actions
-functionapp    For Azure Function App settings and actions
-storage        For Azure Storage settings and actions
-subscriptions  For Azure account and subscriptions settings and actions
-
-Actions:
-get-publish-username  Get the source control publishing username for a Function App in Azure
-set-publish-password  Set the source control publishing password for a Function App in Azure
-login                 Log in to an Azure account. Can also do "func azure login"
-logout                Log out of Azure account. Can also do "func azure logout"
-portal                Launch default browser with link to the current app in https://portal.azure.com
-```
-
-```
-func azure account
-Usage: func azure account <action> [-/--options]
-
-Actions:
-set <subscriptionId> Set the active subscription
-list  List subscriptions for the logged in user
-```
-
-```
-func azure functionapp
-Usage: func azure functionapp <action> [-/--options]
-
-Actions:
-enable-git-repo     Enable git repository on your Azure-hosted Function App
-fetch-app-settings  Retrieve App Settings from your Azure-hosted Function App and store locally. Alias: fetch
-list                List all Function Apps in the selected Azure subscription
-```
-
-The `func azure storage list` command will show storage accounts in the selected subscription. You can then set up a connection string locally with this storage account name using `func settings add-storage-account`.
-
-```
-func azure storage
-Usage: func Azure Storage <action> [-/--options]
-
-Actions:
-list  List all Storage Accounts in the selected Azure subscription
-```
-
-### Local actions
-
-Actions that are not in the "azure" context operate on the local environment. For instance, `func settings list` will show the app settings for the current function app.
-
-```
-func settings
-Usage: func settings [context] <action> [-/--options]
-
-Actions:
-add                  Add new local app setting to appsettings.json
-add-storage-account  Add a local app setting using the value from an Azure Storage account. Requires Azure login.
-decrypt              Decrypt the local settings file
-delete               Remove a local setting
-encrypt              Encrypt the local settings file
-list                 List local settings
-```
-
-```
-func function
-Usage: func function [context] <action> [-/--options]
-
-Actions:
-create  Create a new Function from a template, using the Yeoman generator
-run     Run a function directly
-```
-
-For consistency, the `func init` command can also be invoked via `func function app init`.
-
-```
-func functionapp init
-```
-
-## Default Directories
-
-* `CurrentDirectory`: is the default directory the functions runtime looks for functions in.
-* `%TMP%\LogFiles\Application\Functions`: is the default directory for logs. It mirrors the logs directory on Azure as well.
-
-## License
-
-This project is under the benevolent umbrella of the [.NET Foundation](http://www.dotnetfoundation.org/) and is licensed under [the MIT License](LICENSE.txt)
-
-This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
-
-## Contact Us
-
-For questions on Azure Functions or the CLI, you can ask questions here:
-
-- [Azure Functions MSDN Forum](https://social.msdn.microsoft.com/Forums/azure/en-US/home?forum=AzureFunctions)
-- [Azure-Functions tag on StackOverflow](http://stackoverflow.com/questions/tagged/azure-functions)
-
-File bugs at [Azure Functions CLI repo on GitHub](https://github.com/Azure/azure-functions-cli/issues).
+![Azure Functions Logo](https://raw.githubusercontent.com/Azure/azure-functions-core-tools/refs/heads/main/eng/res/functions.png)
+
+|Branch|Status|
+|------|------|
+|main|[![Build Status](https://dev.azure.com/azfunc/public/_apis/build/status%2Fazure%2Fazure-functions-core-tools%2Fcoretools.public?repoName=Azure%2Fazure-functions-core-tools&branchName=main)](https://dev.azure.com/azfunc/public/_build/latest?definitionId=579&repoName=Azure%2Fazure-functions-core-tools&branchName=main) |
+|vnext|[![Build Status](https://dev.azure.com/azfunc/public/_apis/build/status%2Fazure%2Fazure-functions-core-tools%2Fcoretools.public?repoName=Azure%2Fazure-functions-core-tools&branchName=vnext)](https://dev.azure.com/azfunc/public/_build/latest?definitionId=579&repoName=Azure%2Fazure-functions-core-tools&branchName=vnext)|
+
+# Azure Functions Core Tools
+
+The Azure Functions Core Tools provide a local development experience for creating, developing, testing, running, and debugging Azure Functions.
+
+## Installation
+
+### One-line install
+
+**PowerShell** (Windows, macOS, Linux):
+
+```powershell
+irm https://aka.ms/func-cli/install.ps1 | iex
+```
+
+**Bash** (macOS, Linux):
+
+```bash
+curl -sSL https://aka.ms/func-cli/install.sh | bash
+```
+
+Both scripts auto-detect your OS and architecture, download the latest 5.x release from GitHub, and install to `~/.azure-functions`.
+
+> v5 is currently pre-release only. Add `--prerelease` / `-Prerelease` (see below) until the first stable 5.x ships.
+
+If a v4 `func` is already on PATH (e.g., from npm), the installer leaves it as the default and installs a `func5` wrapper alongside so you can run v5 side-by-side without breaking v4.
+
+### Options
+
+Pass flags to the installer using the patterns below. The PowerShell script also supports `-WhatIf` to preview changes without writing anything, plus the standard `-Verbose`, `-SkipPath`, and `-KeepArchive` switches; the Bash script exposes the same via `--dry-run`, `--verbose`, `--skip-path`, `--keep-archive`, and prints the full list with `--help`.
+
+| Option | PowerShell | Bash |
+|--------|-----------|------|
+| Include pre-releases | `iex "& { $(irm https://aka.ms/func-cli/install.ps1) } -Prerelease"` | `curl -sSL https://aka.ms/func-cli/install.sh \| bash -s -- --prerelease` |
+| Specific version | `iex "& { $(irm https://aka.ms/func-cli/install.ps1) } -Version 5.0.0"` | `curl -sSL https://aka.ms/func-cli/install.sh \| bash -s -- --version 5.0.0` |
+| Custom install dir | `iex "& { $(irm https://aka.ms/func-cli/install.ps1) } -InstallPath ~/my-tools"` | `curl -sSL https://aka.ms/func-cli/install.sh \| bash -s -- --install-path ~/my-tools` |
+| Preview without writing | `iex "& { $(irm https://aka.ms/func-cli/install.ps1) } -WhatIf"` | `curl -sSL https://aka.ms/func-cli/install.sh \| bash -s -- --dry-run` |
+| Show help | `iex "& { $(irm https://aka.ms/func-cli/install.ps1) } -Help"` | `curl -sSL https://aka.ms/func-cli/install.sh \| bash -s -- --help` |
+
+The Bash script also still honours the legacy environment variables (`VERSION`, `PRERELEASE=true`, `INSTALL_DIR`, `FORCE=true`, `SOURCE`) for back-compat. Flags take precedence.
+
+### Unattended install
+
+To chain commands after the installer (e.g., in CI pipelines or Dockerfiles), source the updated PATH and then run `func` directly:
+
+**PowerShell:**
+
+```powershell
+iex "& { $(irm https://aka.ms/func-cli/install.ps1) }"
+func workload install dotnet
+```
+
+**Bash:**
+
+```bash
+curl -sSL https://aka.ms/func-cli/install.sh | bash
+source ~/.bashrc
+func workload install node
+```
+
+The install script adds `~/.azure-functions` to your PATH automatically. In PowerShell, the current session is updated immediately. In Bash, you need to `source` your shell profile to pick up the change before running `func`.
+
+In GitHub Actions, the installer also appends the install dir to `$GITHUB_PATH`, so `func` is on PATH in subsequent steps without needing to source anything.
+
+## Usage
+
+```bash
+func <command> [path] [options]
+```
+
+| Command | Description |
+|---------|-------------|
+| `func init [path]` | Initialize a new Azure Functions project |
+| `func new [path]` | Create a new function from a template |
+| `func run [path]` | Start the Functions host locally (alias: `func start`) |
+| `func workload install <id>` | Install a language workload |
+| `func workload list` | List installed workloads |
+| `func version` | Display version information |
+| `func help [command]` | Display help for a command |
+
+## Architecture
+
+The v5 CLI is a ground-up rebuild using:
+
+- **System.CommandLine 2.0.6** — command parsing (following the dotnet CLI model)
+- **Spectre.Console** — rich terminal output (tables, prompts, spinners)
+- **Dependency Injection** — Microsoft.Extensions.DependencyInjection
+- **.NET 10** — target framework
+- **Workload model** — core CLI + optional language workloads (dotnet, node, python, etc.)
+
+## Project Structure
+
+```
+src/
+  Func/                    # CLI application
+    Commands/              # Command definitions (one file per command)
+    Console/               # Console output abstractions (Spectre wrappers)
+    Workloads/             # Workload engine (contracts, manager, manifest)
+    Program.cs             # Entry point with DI wiring
+    Parser.cs              # Command tree composition
+  Abstractions/            # Public abstractions
+  Workloads/
+    <kind>/<Name>/         # An individual grouped workload
+    <Name>/                # An individual ungrouped workload
+test/
+  Func.Tests/              # Unit tests core cli (xUnit + NSubstitute)
+  Workloads/
+    <kind>/<Name>.Tests/   # Unit tests for a grouped workload
+    <Name>.Tests/          # Unit tests for an ungrouped workload
+eng/
+  build/                   # MSBuild props and targets
+  ci/                      # CI pipeline definitions (Azure DevOps)
+  scripts/                 # Build and validation scripts
+  res/                     # Resources (icons, MSI assets)
+docs/
+  vnext.md                 # v5 design document
+  modernization.md         # Modernization design document
+Azure.Functions.Cli.slnx   # Solution file
+```
+
+## Development
+
+**Prerequisites:** .NET 10 SDK (see `global.json` for the exact version)
+
+### Build
+
+```bash
+dotnet restore
+dotnet build
+```
+
+### Test
+
+```bash
+dotnet test
+```
+
+### Run Locally
+
+```bash
+# Option 1 — dotnet run
+dotnet run --project src/Func -- <command> [args]
+
+# Option 2 — add to PATH
+export PATH="$PATH:$(pwd)/out/bin/Func/debug"
+func <command>
+```
+
+### Set Up Language Workloads
+
+`func setup` installs the host and the selected language's stack and worker workloads,
+plus templates and extension bundles where applicable. Supported stacks are `dotnet`,
+`node`, `python`, `go`, `java`, and `powershell`. For example:
+
+```bash
+func setup --features java --yes
+func setup --features powershell --yes
+```
+
+In an existing project, setup uses its configured runtime when `--features` is omitted.
+`func setup --check` checks the same dependencies without installing them and returns
+a nonzero exit code when a required stack workload is missing.
+
+### Run Locally with Workloads
+
+One-time bootstrap (per workload you want to test, into ./.debug-workloads/):
+
+```bash
+dotnet build src/Func/Func.csproj
+dotnet build src/Workloads/Stacks/Node/Workloads.Node.csproj \
+ -t:DeployForDebug -p:FuncCliEnsureWorkloadInstalled=true
+```
+
+That packs the workload, runs func workload install against `./.debug-workloads/`, and drops the freshly built DLL+PDB into the install dir.
+
+Inner loop (after editing workload source, no re-install, no pack):
+
+```bash
+dotnet build src/Workloads/Stacks/Node/Workloads.Node.csproj -t:DeployForDebug
+```
+
+> Just copies the new DLL+PDB over the installed one.
+
+Run the CLI against that home:
+
+```bash
+export FUNC_CLI_WORKLOADS_HOME="$PWD/.debug-workloads"
+./out/bin/Func/debug/func <args>
+```
+
+#### One-shot script
+
+`eng/scripts/debug-workloads.ps1` wraps the above for every workload in the repo, so you can bootstrap a full home in one command:
+
+```bash
+pwsh ./eng/scripts/debug-workloads.ps1                  # all workloads
+pwsh ./eng/scripts/debug-workloads.ps1 -Project Node    # just one
+pwsh ./eng/scripts/debug-workloads.ps1 -Feature node    # everything `func setup --features node` installs
+pwsh ./eng/scripts/debug-workloads.ps1 -Clean           # wipe + reinstall
+```
+
+`-Feature` accepts `host`, `runtime`, `dotnet`, `node`, `python`, `go`, `java`, `powershell` (or any combination, deduped).
+
+Inner loop with the script (sub-second, copy-only):
+
+```bash
+pwsh ./eng/scripts/debug-workloads.ps1 -Project Node -SkipFuncBuild
+```
+
+Reach for the `build-workloads` skill instead when what you're testing is `func workload install` itself (feed resolution, manifest behaviour, etc.). Otherwise the script above is faster because it skips the NuGet feed.
+
+### Publish a Self-Contained Build
+
+```bash
+dotnet publish src/Func/Func.csproj -c Release -r osx-arm64
+./out/pub/Func/release_osx-arm64/func --version
+```
+
+Common runtime identifiers: `osx-arm64`, `osx-x64`, `linux-x64`, `win-x64`
+
+## Branches
+
+| Branch | Description |
+|--------|-------------|
+| `main` | v4 — current stable release |
+| `vnext` | v5 — next-generation CLI rebuild |
+
+## Documentation
+
+- [Code and test Azure Functions locally](https://docs.microsoft.com/azure/azure-functions/functions-run-local)
+- [Contributing Guide](CONTRIBUTING.md)
+- [Design proposals](proposed/)
+
+Files under `proposed/` capture design intent while a design is being shaped and reviewed, so they may lag the current implementation. Submit new proposals against `vnext`; after a design is accepted and implemented, move it to `accepted/` in a follow-up change.
+
+## Telemetry
+
+The Azure Functions Core Tools collect usage data in order to help us improve your experience.
+The data is anonymous and doesn't include any user specific or personal information. The data is collected by Microsoft.
+
+You can opt-out of telemetry by setting the `FUNC_CLI_TELEMETRY_OPTOUT` environment variable to any value other than `no`, `n`, `0`, `false`, or `off`. The legacy `FUNCTIONS_CORE_TOOLS_TELEMETRY_OPTOUT` variable from Core Tools v4 is still honored.
+
+[Microsoft privacy statement](https://privacy.microsoft.com/privacystatement)
+
+## License
+
+This project is under the benevolent umbrella of the [.NET Foundation](http://www.dotnetfoundation.org/) and is licensed under [the MIT License](LICENSE).
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+## Contact Us
+
+For questions on Azure Functions or the tools:
+
+- [Azure Functions Q&A Forum](https://docs.microsoft.com/answers/topics/azure-functions.html)
+- [Azure-Functions tag on StackOverflow](http://stackoverflow.com/questions/tagged/azure-functions)
+- [File bugs on GitHub](https://github.com/Azure/azure-functions-core-tools/issues)

package/lib/copy-metadata.js

@@ -0,0 +1,9 @@
+const fs = require('fs');
+const path = require('path');
+
+const repositoryRoot = path.resolve(__dirname, '..', '..', '..', '..', '..');
+const packageRoot = path.resolve(__dirname, '..');
+
+for (const fileName of ['LICENSE', 'README.md']) {
+    fs.copyFileSync(path.join(repositoryRoot, fileName), path.join(packageRoot, fileName));
+}

package/lib/install.js

@@ -0,0 +1,151 @@
+#! /usr/bin/env node
+
+const fs = require('fs');
+const https = require('https');
+const { HttpsProxyAgent } = require('https-proxy-agent');
+const os = require('os');
+const path = require('path');
+const ProgressBar = require('progress');
+const yauzl = require('yauzl');
+const { version } = require('../package.json');
+
+function getRuntimeIdentifier() {
+    const platforms = {
+        darwin: 'osx',
+        linux: 'linux',
+        win32: 'win'
+    };
+    const architectures = {
+        arm64: 'arm64',
+        x64: 'x64'
+    };
+    const platform = platforms[os.platform()];
+    const architecture = architectures[os.arch()];
+
+    if (!platform || !architecture) {
+        throw new Error(`Platform '${os.platform()}-${os.arch()}' is not supported.`);
+    }
+
+    return `${platform}-${architecture}`;
+}
+
+function getProxyAgent() {
+    const proxy = process.env.npm_config_https_proxy
+        || process.env.npm_config_proxy
+        || process.env.HTTPS_PROXY
+        || process.env.https_proxy
+        || process.env.HTTP_PROXY
+        || process.env.http_proxy;
+
+    return proxy ? new HttpsProxyAgent(proxy) : undefined;
+}
+
+function download(url, destination, redirectCount = 0) {
+    return new Promise((resolve, reject) => {
+        const request = https.get(url, { agent: getProxyAgent() }, response => {
+            if ([301, 302, 307, 308].includes(response.statusCode)) {
+                response.resume();
+                if (!response.headers.location || redirectCount >= 5) {
+                    reject(new Error(`Unable to follow redirect while downloading '${url}'.`));
+                    return;
+                }
+
+                resolve(download(new URL(response.headers.location, url), destination, redirectCount + 1));
+                return;
+            }
+
+            if (response.statusCode !== 200) {
+                response.resume();
+                reject(new Error(`Failed to download '${url}'. Expected HTTP 200, received ${response.statusCode}.`));
+                return;
+            }
+
+            const total = Number(response.headers['content-length']) || 0;
+            const progress = total > 0
+                ? new ProgressBar('[:bar] Downloading Azure Functions CLI', { total, width: 18 })
+                : undefined;
+            const file = fs.createWriteStream(destination);
+
+            response.on('data', data => progress?.tick(data.length));
+            response.on('error', reject);
+            file.on('error', reject);
+            file.on('finish', () => file.close(resolve));
+            response.pipe(file);
+        });
+
+        request.on('error', reject);
+        request.setTimeout(300000, () => {
+            request.destroy(new Error(`Timed out downloading '${url}'.`));
+        });
+    });
+}
+
+function extractExecutable(archivePath, destination) {
+    const expectedEntry = os.platform() === 'win32' ? 'func.exe' : 'func';
+
+    return new Promise((resolve, reject) => {
+        yauzl.open(archivePath, { lazyEntries: true }, (openError, archive) => {
+            if (openError) {
+                reject(openError);
+                return;
+            }
+
+            archive.on('error', reject);
+            archive.on('end', () => {
+                reject(new Error(`Archive does not contain '${expectedEntry}'.`));
+            });
+            archive.on('entry', entry => {
+                if (entry.fileName !== expectedEntry) {
+                    archive.readEntry();
+                    return;
+                }
+
+                archive.openReadStream(entry, (streamError, input) => {
+                    if (streamError) {
+                        archive.close();
+                        reject(streamError);
+                        return;
+                    }
+
+                    const output = fs.createWriteStream(destination, { mode: 0o755 });
+                    input.on('error', reject);
+                    output.on('error', reject);
+                    output.on('close', () => {
+                        archive.close();
+                        resolve();
+                    });
+                    input.pipe(output);
+                });
+            });
+            archive.readEntry();
+        });
+    });
+}
+
+async function install() {
+    const runtimeIdentifier = getRuntimeIdentifier();
+    const packageRoot = path.resolve(__dirname, '..');
+    const binDirectory = path.join(packageRoot, 'bin');
+    const archiveName = `Azure.Functions.Cli.${runtimeIdentifier}.${version}.zip`;
+    const archivePath = path.join(binDirectory, archiveName);
+    const executablePath = path.join(binDirectory, os.platform() === 'win32' ? 'func.exe' : 'func');
+    const endpoint = `https://cdn.functions.azure.com/public/cli/v5/${version}/${archiveName}`;
+
+    fs.rmSync(binDirectory, { recursive: true, force: true });
+    fs.mkdirSync(binDirectory, { recursive: true });
+
+    try {
+        console.log(`Downloading Azure Functions CLI from '${endpoint}'.`);
+        await download(endpoint, archivePath);
+        await extractExecutable(archivePath, executablePath);
+        fs.rmSync(archivePath, { force: true });
+    } catch (error) {
+        fs.rmSync(binDirectory, { recursive: true, force: true });
+        throw error;
+    }
+}
+
+install().catch(error => {
+    console.error(error.message);
+    process.exitCode = 1;
+});