### Start Tenant Services

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/start.md

This section covers the basic usage of the `sfp server start` command to initiate services for a specified tenant. It highlights the required `--tenant` flag and provides examples for common scenarios.

```APIDOC
## `sfp server start`

### Description
Start or restart the services for a specified tenant.

### Method
CLI Command

### Parameters
#### Required Flags
- **-t, --tenant** (string) - Required - Name of the tenant to start

#### Optional Flags
- **-j, --[no-]json** (boolean) - Output in JSON format
- **--daemon** (boolean) - Run server in daemon mode (detached)
- **--no-browser** (boolean) - Disable automatic browser opening
- **--base-dir** (string) - [default: ./sfp-server] Base Directory which contains the sfp-server
- **--restart** (boolean) - Restart server if already running
- **--config-file** (string) - Path to JSON config file containing server configuration values

### SSH OPTIONS
#### Optional Flags
- **--ssh-connection** (string) - SSH connection string in the format user@host[:port]
- **--identity-file** (string) - Path to SSH private key file
- **--passphrase** (string) - Passphrase for the SSH private key if required

### SECRETS MANAGEMENT
#### Optional Flags
- **--secrets-provider** (string) - [default: custom] Secret provider to use for managing secrets (options: infisical|aws-secretsmanager|custom)
- **--infisical-token** (string) - Infisical API token (required when secrets-provider is "infisical")
- **--aws-region** (string) - AWS region for Secrets Manager (required when secrets-provider is "aws-secretsmanager")
- **--aws-access-key-id** (string) - AWS access key ID (optional, can use instance profile)
- **--aws-secret-access-key** (string) - AWS secret access key (optional, can use instance profile)

### OTHER OPTIONS
#### Optional Flags
- **-g, --logsgroupsymbol** (string array) - Symbol used by CICD platform to group/collapse logs
- **--loglevel** (string) - [default: info] logging level for this command invocation (options: trace|debug|info|warn|error|fatal)

### Request Example
```bash
sfp server start --tenant my-app
```

### Modes of Operation
#### Daemon Mode
Run the server in the background (detached):
```bash
sfp server start --tenant my-app --daemon
```

#### Interactive Mode
Run the server in the foreground (default):
```bash
sfp server start --tenant my-app
```

### Secrets Management
#### Custom Provider (Default)
Use environment variables injected by external tools:
```bash
# Using Infisical CLI
infisical run -- sfp server start --tenant my-app --secrets-provider custom

# Using AWS CLI with SSM Parameter Store
aws ssm get-parameters-by-path --path /sfp/my-app --recursive | \
  jq -r ".Parameters[] | \"export \( .Name | split(\" / \") | last )=\( .Value )\"" | \
  source /dev/stdin && \
  sfp server start --tenant my-app --secrets-provider custom
```

#### Infisical Provider
Direct integration with Infisical:
```bash
sfp server start --tenant my-app \
  --secrets-provider infisical \
  --infisical-token your-token
```

#### AWS Secrets Manager
Direct integration with AWS Secrets Manager:
```bash
sfp server start --tenant my-app \
  --secrets-provider aws-secretsmanager \
  --aws-region us-east-1
```

### Remote Server Management
Start a tenant on a remote server via SSH:
```bash
sfp server start --tenant my-app \
  --ssh-connection admin@production.example.com:2222 \
  --identity-file ~/.ssh/production_key
```

> **Note**: When using `--restart`, the server will be stopped and started again if it's already running.

> **Tip**: Use `--daemon` mode for production deployments to run the server in the background.
```

--------------------------------

### Register Salesforce Orgs and Create Environments

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/environments/README.md

This outlines the complete flow for environment setup, starting with registering Salesforce orgs (production, DevHub, sandboxes) and then creating environments linked to repository branches.

```bash
┌─────────────────────────────────────────────────────────────────────────────┐
│                    Environment Setup Flow                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│   STEP 1: Register Salesforce Orgs                                           │
│   ────────────────────────────────                                           │
│                                                                              │
│   # Production org (requires local auth first)                               │
│   $ sf org login web --alias production                                      │
│   $ sfp server org register --targetusername production                      │
│                                                                              │
│   # DevHub (if using scratch orgs)                                           │
│   $ sf org login web --alias devhub                                          │
│   $ sfp server org register --targetusername devhub --devhub --default       │
│                                                                              │
│   # Sandboxes (option A: JIT - recommended)                                  │
│   $ sfp server org register-sandbox \
│       --sandboxname uat \
│       --productionusername admin@production.com                              │
│                                                                              │
│   # Sandboxes (option B: direct registration)                                │
│   $ sf org login web --alias uat --instance-url https://test.salesforce.com  │
│   $ sfp server org register --targetusername uat                             │
│                                                                              │
│   STEP 2: Create Environments                                                │
│   ───────────────────────────                                                │
│                                                                              │
│   $ sfp server environment create \
│       --repository myorg/salesforce-app \
│       --name UAT \
│       --category test \
│       --branch release/* \
│       --targetusername admin@production--uat.sandbox.com                     │
│                                                                              │
│   STEP 3: Access Environments                                                │
│   ───────────────────────────                                                │
│                                                                              │
│   $ sfp server environment get \
│       --name UAT \
│       --repository myorg/salesforce-app \
│       --auth-type accessToken \
│       --authenticate                                                         │
│                                                                              │
│   ✅ Ready to use: sfp install --targetorg UAT --artifactdir ./artifacts     │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘
```

--------------------------------

### Example: Basic Server Initialization

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/init.md

A basic example of initializing an SFP server instance for a tenant named 'my-app'.

```bash
sfp server init --tenant my-app
```

--------------------------------

### Example Pre-Validation Script

Source: https://github.com/flxbl-io/docs-sfp/blob/main/validating-a-change/validation-scripts.md

This bash script demonstrates parsing context, performing setup based on validation mode, and notifying an external system.

```bash
#!/bin/bash
set -e

CONTEXT_FILE="$1"
TARGET_ORG="$2"
HUB_ORG="$3"

echo "🔧 Pre-validation setup starting..."

# Parse context
PACKAGES=$(cat "$CONTEXT_FILE" | jq -r '.packages[].name' | tr '\n' ' ')
VALIDATION_MODE=$(cat "$CONTEXT_FILE" | jq -r '.validationMode')

echo "📦 Packages to validate: $PACKAGES"
echo "🎯 Validation mode: $VALIDATION_MODE"
echo "🏢 Target org: $TARGET_ORG"

# Custom setup logic
if [ "$VALIDATION_MODE" = "thorough" ]; then
    echo "🔧 Setting up comprehensive validation environment..."
    # Setup test data, configure external systems, etc.
fi

# Example: Notify external systems
curl -X POST "https://internal-api.company.com/validation/started" \
     -H "Content-Type: application/json" \
     -d "{\"packages\": \"$PACKAGES\", \"targetOrg\": \"$TARGET_ORG\"}"

echo "✅ Pre-validation setup completed"

```

--------------------------------

### Example: Update tenant 'my-tenant'

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/update.md

A basic example of updating services for a tenant named 'my-tenant'.

```bash
sfp server update --tenant my-tenant
```

--------------------------------

### Example: Update tenant 'my-tenant' and restart services

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/update.md

An example of updating services for 'my-tenant' and automatically restarting them afterward.

```bash
sfp server update --tenant my-tenant --restart
```

--------------------------------

### Start Tenant Services

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/start.md

Starts the services for a specified tenant. This is the default interactive mode.

```bash
sfp server start --tenant my-app
```

--------------------------------

### Install sfp-pro on macOS

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/install-sfp/install-sfp-pro.md

Install sfp-pro by first mounting the DMG, dragging the app to Applications, and then running the installer script. Alternatively, run the script from the installed application if the DMG is unmounted.

```bash
sudo bash /Volumes/sfp-pro-*/install-cli.sh
```

```bash
sudo /Applications/sfp-pro.app/Contents/Resources/install-cli.sh
```

--------------------------------

### Install Artifacts Locally

Source: https://github.com/flxbl-io/docs-sfp/blob/main/releasing-artifacts/overview.md

Use the `sfp install` command for local development and testing. It installs artifacts directly from a local directory to a specified target org.

```bash
sfp install --artifacts ./artifacts --targetusername myorg
```

--------------------------------

### Install Changes to Review Environment

Source: https://github.com/flxbl-io/docs-sfp/blob/main/development/development-workflow.md

Install the built artifacts into the fetched review environment for testing.

```bash
# Install the changes
sfp install --target-org pr-123-review \
  --artifacts artifacts
```

--------------------------------

### Example Monitor Sandbox Pools Command

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/pools/sandbox-pools/monitor-sandbox-pools.md

An example demonstrating how to use the monitor command with specific Dev Hub, repository, and configuration files.

```bash
sfp pool sandbox monitor -v my-devhub -r myorg/myrepo -f config/pool-config-1.json config/pool-config-2.json
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/utilities/dependency.md

This command installs all external dependencies for a given project. It requires the target org username and Dev Hub username. Optionally, installation keys can be provided for key-protected packages using the `-k` flag.

```bash
USAGE
  $ @flxbl-io/sfp dependency install -o <value> -v <value> [-k <value>] [--loglevel
    trace|debug|info|warn|error|fatal|TRACE|DEBUG|INFO|WARN|ERROR|FATAL]

FLAGS
  -k, --installationkeys=<value>      Installation key for key-protected packages (format is packagename:key -->
                                      core:key nCino:key vlocity:key to allow some packages without installation key)
  -o, --targetusername=<value>        (required) Username or alias of the target org.
  -v, --targetdevhubusername=<value>  (required) Username or alias of the Dev Hub org.
      --loglevel=<option>             [default: info] logging level for this command invocation
                                      <options: trace|debug|info|warn|error|fatal|TRACE|DEBUG|INFO|WARN|ERROR|FATAL>

DESCRIPTION
  Install all the external dependencies of a given project
```

--------------------------------

### Example: Apex Class with Placeholder

Source: https://github.com/flxbl-io/docs-sfp/blob/main/building-artifacts/configuring-installation-behaviour-of-a-package/string-replacements.md

This Apex class demonstrates the use of a placeholder string that will be replaced during installation. The `ENDPOINT` variable is defined using a placeholder pattern.

```apex
// Single APIService.cls with placeholder
public class APIService {
    private static final String ENDPOINT = '%%API_ENDPOINT%%';
}
```

--------------------------------

### Sandbox Pool Initialization Example Command

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/pools/sandbox-pools/sandbox-pool-initialization.md

This example demonstrates initializing sandbox pools using a specific configuration file, Dev Hub, and GitHub repository. Ensure you have the necessary GitHub/GitLab token with appropriate scopes.

```bash
sfp pool sandbox init -f config/my-sandbox-pools.json -v my-devhub -r myorg/myrepo
```

--------------------------------

### `@flxbl-io/sfp dependency install`

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/utilities/dependency.md

Installs all the external dependencies of a given project.

```APIDOC
## `@flxbl-io/sfp dependency install`

### Description
Install all the external dependencies of a given project.

### Method
CLI Command

### Parameters
#### Flags
- **-k, --installationkeys** (string) - Optional - Installation key for key-protected packages (format is packagename:key --> core:key nCino:key vlocity:key to allow some packages without installation key).
- **-o, --targetusername** (string) - Required - Username or alias of the target org.
- **-v, --targetdevhubusername** (string) - Required - Username or alias of the Dev Hub org.
- **--loglevel** (option) - Optional - Logging level for this command invocation. Options: trace, debug, info, warn, error, fatal.

### Request Example
```bash
@flxbl-io/sfp dependency install -o MyTargetOrg -v MyDevHubUsername
@flxbl-io/sfp dependency install -o MyTargetOrg -v MyDevHubUsername -k core:mykey
```

### Response
No specific response details provided in the source.
```

--------------------------------

### Example Sandbox Creation

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/sandbox/create-sandbox.md

This example demonstrates creating a sandbox named 'MySandbox1' from a source sandbox named 'SourceSandbox', using 'MyDevHub' as the target Dev Hub.

```sh
$ sfp sandbox:create -v MyDevHub -n MySandbox1 -s SourceSandbox
```

--------------------------------

### Install sfp CLI

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/install-sfp/install-sfp-community-edition.md

Installs the sfp command-line interface globally using npm. Ensure Node.js and npm are installed on your system.

```bash
npm i -g @flxbl-io/sfp
```

--------------------------------

### Environment Structure Example

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/environments/README.md

An example illustrating the components that define an environment, including repository, branch, Salesforce org, category, and metadata.

```yaml
Environment: "UAT"
├── Repository: myorg/salesforce-app
├── Branch: release/v2.0
├── Salesforce Org: admin@uat.sandbox.com  (must be registered first)
├── Category: test
└── Metadata: { "region": "US", "owner": "qa-team" }
```

--------------------------------

### Install Artifacts for Development

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/environments/accessing-environments.md

Retrieve your development environment and install artifacts. This authenticates the org locally as 'Dev' for development purposes.

```bash
# Get your dev environment
sfp server environment get \
  --name dev \
  --repository myorg/salesforce-app \
  --auth-type accessToken \
  --authenticate

# Start developing - org is now authenticated locally as "Dev"
sfp install -o dev -v devhub -p core
```

--------------------------------

### Example Release Command with Changelog Generation

Source: https://github.com/flxbl-io/docs-sfp/blob/main/releasing-artifacts/generating-a-changelog.md

This example demonstrates how to use the `sfp release` command with the `--generatechangelog` and `--branchname` flags to create and update changelog files.

```yaml
sfp release -u prod \
            -p  releasedefn.yaml \
            --npm --scope flxbl \
            -v prod \
             --generatechangelog --branchname changelog
```

--------------------------------

### Example Release Definition

Source: https://github.com/flxbl-io/docs-sfp/blob/main/releasing-artifacts/release-definitions.md

A complete example of a release definition file, outlining the structure and common attributes.

```yaml
release: Sprint-2-13-11-6844956242
skipIfAlreadyInstalled: true
artifacts:
  feature-management: 1.0.19-6844956242
  apex-logger: 1.0.20-89
promotePackagesBeforeDeploymentToOrg: prod
changelog:
  workItemFilters:
    - (FGK|FFK)-[0-9]{3,4}
  workItemUrl: https://flxbl.atlassian.net/browse
  limit: 30
```

--------------------------------

### Install sfp-pro on Debian/Ubuntu

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/install-sfp/install-sfp-pro.md

Use dpkg to install the sfp-pro DEB package. Ensure you have the correct DEB filename.

```bash
sudo dpkg -i sfp-pro_*.deb
```

--------------------------------

### Sandbox Fetch Example

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/pools/sandbox-pools/fetch-a-sandbox-from-pool.md

This example demonstrates fetching a sandbox from 'dev-pool' for a specific branch and issue, and leasing it for an extended period. Ensure your GitHub/GitLab token has the required scopes.

```bash
sfp pool sandbox fetch --repository myorg/myrepo --pool dev-pool --branch feature/new-feature --issue 1234 --leasefor 60
```

--------------------------------

### Deploy to Environment

Source: https://github.com/flxbl-io/docs-sfp/blob/main/auth-management/authentication.md

Install or deploy your application to a specified environment.

```bash
$ sfp install --targetorg UAT
```

--------------------------------

### Full AI Assist Configuration File Example

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/configuring-llm-providers.md

A comprehensive example of the ai-assist.yaml configuration file, demonstrating settings for enabling AI features, selecting providers and models, and defining analysis patterns, principles, and focus areas.

```yaml
# Enable/disable AI features
enabled: true

# Provider Configuration
provider: anthropic  # anthropic, openai, amazon-bedrock, github-copilot

# Model Configuration (Optional - uses provider defaults if not specified)
# Default models:
# - anthropic: claude-sonnet-4-5-20250929
# - openai: gpt-4o
# - github-copilot: gpt-4o
# - amazon-bedrock: anthropic.claude-sonnet-4-5-20250929-v1:0
model: claude-sonnet-4-5-20250929  # Override default model

# Architectural Patterns to Check (for PR Linter)
patterns:
  - singleton
  - factory
  - repository
  - service-layer

# Architecture Principles
principles:
  - separation-of-concerns
  - single-responsibility
  - dependency-inversion

# Focus Areas for Analysis
focusAreas:
  - security
  - performance
  - maintainability
  - testability

# Additional Context Files
contextFiles:
  - ARCHITECTURE.md
  - docs/patterns.md
  - docs/coding-standards.md
```

--------------------------------

### Install sfp-pro on Windows

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/install-sfp/install-sfp-pro.md

Use msiexec to install the sfp-pro MSI package. Ensure you have the correct MSI filename.

```powershell
msiexec /i sfp-pro-*.msi
```

--------------------------------

### Start Tenant Services with Custom Provider using AWS CLI

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/start.md

Demonstrates starting tenant services with a custom secrets provider by fetching secrets from AWS SSM Parameter Store and sourcing them as environment variables.

```bash
aws ssm get-parameters-by-path --path /sfp/my-app --recursive | \
  jq -r '.Parameters[] | "export ".Name | split("/") | last)=".Value"' | \
  source /dev/stdin && \
  sfp server start --tenant my-app --secrets-provider custom
```

--------------------------------

### Example Release Configuration for Sales Domain

Source: https://github.com/flxbl-io/docs-sfp/blob/main/validating-a-change/limiting-validation-by-domain.md

An example YAML configuration file defining packages to include and skip for the Sales domain. Use this with the `--releaseconfig` flag.

```yaml
# config/release-sales.yml
name: Sales Domain
includeOnlyPackages:
  - sales-core
  - sales-ui
  - sales-integrations
  - opportunity-management
  - quote-management
skipPackages:
  - sales-deprecated
```

--------------------------------

### `@flxbl-io/sfp install`

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/core/install.md

Installs artifact(s) from a given directory to a target org. This command allows for flexible deployment options including test execution control and artifact filtering.

```APIDOC
## `@flxbl-io/sfp install`

### Description
Installs artifact(s) from a given directory to a target org.

### Method
CLI Command

### Usage
`@flxbl-io/sfp install -o <value> [--artifactdir <value>] [--waittime <value>] [-t <value>] [-b <value> --skipifalreadyed] [-p <value>] [--releaseconfig <value>] [--enablesourcetracking] [--runtests] [-g <value>] [--loglevel trace|debug|info|warn|error|fatal|TRACE|DEBUG|INFO|WARN|ERROR|FATAL]`

### Flags
#### Path Parameters
- **-o, --targetorg** (string) - Required - Username or alias of the target org.
- **-t, --tag** (string) - Tag the deploy with a label, useful for identification in metrics.
- **-p, --artifacts** (string[]) - Only install artifacts for the provided packages, use comma separated list of package names if there are multiple packages.
- **-b, --baselineorg** (string) - The org against which the package skip should be baselined.
- **-g, --logsgroupsymbol** (string[]) - Symbol used by CICD platform to group/collapse logs in the console. Provide an opening group, and an optional closing group symbol.
- **--artifactdir** (string) - [default: artifacts] The directory containing artifacts to be deployed.
- **--waittime** (string) - [default: 120] Wait time for command to finish in minutes.
- **--releaseconfig** (string) - Path to the config file which determines how the packages are deployed based on the filters in release config.
- **--loglevel** (string) - [default: info] logging level for this command invocation. Options: trace|debug|info|warn|error|fatal|TRACE|DEBUG|INFO|WARN|ERROR|FATAL.

#### Boolean Flags
- **--skipifalreadyinstalled** - Skip the package installation if the package is already installed in the org.
- **--enablesourcetracking** - Enable source tracking on the packages being deployed to an org.
- **--runtests** - Force execution of tests during installation (tests are skipped by default).

### Description
Installs artifact(s) from a given directory to a target org

### Aliases
`$ @flxbl-io/sfp orchestrator deploy`
`$ @flxbl-io/sfp deploy`

### Examples
```bash
$ sfp install -o <username>
$ sfp install -o <username> --runtests
```
```

--------------------------------

### Start Tenant Services with Custom Provider using Infisical CLI

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/start.md

Demonstrates starting tenant services with a custom secrets provider by first running the command through `infisical run` to inject environment variables.

```bash
infisical run -- sfp server start --tenant my-app --secrets-provider custom
```

--------------------------------

### SFDX Auth URL Example

Source: https://github.com/flxbl-io/docs-sfp/blob/main/auth-management/sfdx-auth-url.md

An example of a complete SFDX Auth URL, illustrating the placement of clientId, clientSecret, refreshToken, and instanceUrl.

```text
force://PlatformCLI::5Aep861_XXXXX.YYYYY@login.salesforce.com
```

--------------------------------

### Start Tenant Services with SSH

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/start.md

Starts the services for a specified tenant on a remote server via SSH, using a specific connection string and identity file.

```bash
sfp server start --tenant my-app --ssh-connection user@example.com --identity-file ~/.ssh/id_rsa
```

--------------------------------

### SFDX Auth URL Examples

Source: https://github.com/flxbl-io/docs-sfp/blob/main/auth-management/connected-apps.md

Provides examples of SFDX Auth URLs, differentiating between the default Salesforce CLI app and a custom connected app.

```text
force://PlatformCLI::5Aep861_XXXXX@login.salesforce.com
```

```text
force://3MVG9d8...:7EF234...:5Aep861_XXXXX@login.salesforce.com
```

--------------------------------

### Start Tenant Services with Infisical Provider

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/start.md

Starts the services for a specified tenant, integrating directly with Infisical for secrets management using an provided token.

```bash
sfp server start --tenant my-app --secrets-provider infisical --infisical-token your-token
```

--------------------------------

### JSON Output Example

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/update.md

This is an example of the JSON output format for a successful tenant update. It includes details such as the tenant name, status, backup location, version information, migration status, and timestamp.

```json
{
  "tenant": "my-tenant",
  "status": "success",
  "backup": "./sfp-server/tenants/my-tenant/backups/backup-2024-01-15",
  "version": {
    "previous": "v2.2.0",
    "current": "v2.3.0"
  },
  "migrations": {
    "applied": 2,
    "pending": 0
  },
  "services": "restarted",
  "timestamp": "2024-01-15T10:30:00Z"
}
```

--------------------------------

### Example: Initialization with Configuration File

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/init.md

Initializes an SFP server for 'my-app' using a predefined configuration from a JSON file.

```bash
sfp server init --tenant my-app --config-file ./server-config.json
```

--------------------------------

### Initial Environment Setup (Admin)

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/environments/accessing-environments.md

Commands for an administrator to set up environments, including authenticating, registering orgs (production, DevHub), registering sandboxes with JIT, and creating environments with specific branches and descriptions.

```bash
# 1. Authenticate as admin
sfp server auth login --admin --email admin@company.com

# 2. Register the production org
sf org login web --alias production
sfp server org register --targetorg production

# 3. Register DevHub
sf org login web --alias devhub
sfp server org register --targetorg devhub --is-devhub --is-default

# 4. Register sandboxes with JIT
sfp server org register-sandbox --sandbox-name uat --production-username admin@production.com
sfp server org register-sandbox --sandbox-name sit --production-username admin@production.com

# 5. Create environments
sfp server environment create \
  --repository myorg/salesforce-app \
  --name Production \
  --category release \
  --branch main \
  --description "Production environment" \
  --targetusername admin@production.com

sfp server environment create \
  --repository myorg/salesforce-app \
  --name UAT \
  --category test \
  --branch release/* \
  --description "User Acceptance Testing" \
  --targetusername admin@production--uat.sandbox.com

sfp server environment create \
  --repository myorg/salesforce-app \
  --name SIT \
  --category test \
  --branch develop \
  --description "System Integration Testing" \
  --targetusername admin@production--sit.sandbox.com
```

--------------------------------

### JSON Output Example

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/releasedefinition.md

Shows the structure of the release definition when output in JSON format.

```json
{
  "releaseName": "MyRelease",
  "releaseId": "rel_abc123",
  "gitRef": "abc123def456",
  "branch": "main",
  "artifacts": {
    "core-package": "v1.2.3",
    "auth-module": "v2.0.1",
    "ui-components": "v3.1.0"
  },
  "metadata": {
    "environment": "production",
    "createdAt": "2024-01-15T10:30:00Z",
    "createdBy": "user@example.com"
  },
  "status": "published",
  "url": "https://sfp.example.com/releases/rel_abc123"
}
```

--------------------------------

### Developer Access to Environments

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/environments/accessing-environments.md

Commands for a developer to access environments after initial setup. This includes authenticating with GitHub, listing available environments, and getting a specific environment for development.

```bash
# Developer authenticates with their GitHub account
sfp server auth login --provider github

# Developer can view environments
sfp server environment list --repository myorg/salesforce-app

# Developer accesses their assigned environment
sfp server environment get \
  --name SIT \
  --repository myorg/salesforce-app \
  --auth-type accessToken \
  --authenticate

# Developer can now work with the SIT environment
sf project deploy start --source-dir force-app --target-org SIT
```

--------------------------------

### Example: Initialization with Force Overwrite

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/init.md

Initializes an SFP server for 'my-app', forcing an overwrite of any existing tenant configuration.

```bash
sfp server init --tenant my-app --force
```

--------------------------------

### Verify sfp-pro Installation

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/install-sfp/install-sfp-pro.md

Run the sfp --version command to confirm that sfp-pro has been installed correctly and to check the installed version.

```bash
sfp --version
```

--------------------------------

### Standard Output Example

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/stop.md

Illustrates the standard output format when stopping services for a tenant.

```text
Stopping services for tenant: my-app
✓ Stopped API server
✓ Stopped critical workers
✓ Stopped normal workers
✓ Stopped batch workers
✓ All services stopped successfully
```

--------------------------------

### Example: Development Mode Initialization with Interactive Secrets

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/init.md

Initializes an SFP server in development mode for 'my-app', prompting the user interactively for secrets.

```bash
sfp server init --tenant my-app --mode dev --interactive
```

--------------------------------

### Install a Single Package

Source: https://github.com/flxbl-io/docs-sfp/blob/main/development/development-workflow.md

Install a single package from the artifacts directory to your target org. This is typically used for testing installation processes.

```bash
# Install a single package
sfp install --target-org my-feature-org \
  --artifacts artifacts \
  --package payment-processing
```

--------------------------------

### Quick Reference: Login to Server

Source: https://github.com/flxbl-io/docs-sfp/blob/main/auth-management/authentication.md

Log in to the server using a specified provider.

```bash
sfp server auth login --provider github
```

--------------------------------

### Install sfpowerscripts-artifact Unlocked Package

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/setup-salesforce-org.md

Install the sfpowerscripts-artifact unlocked package using the sf CLI. This package is required for sfp to track installed artifacts and skip redundant installations. Ensure you replace `<your_org_alias>` with your actual org alias.

```bash
sf package install --package 04t1P000000ka9mQAA -o <your_org_alias> --security-type=AdminsOnly --wait=120
```

--------------------------------

### Quick Reference: List Environments

Source: https://github.com/flxbl-io/docs-sfp/blob/main/auth-management/authentication.md

List all available environments for a given repository.

```bash
sfp server environment list --repository REPO
```

--------------------------------

### Example: Production Mode Initialization with Custom Domain and Workers

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/init.md

Initializes an SFP server in production mode for 'my-app' with a specified domain and custom worker counts for critical, normal, and batch queues.

```bash
sfp server init --tenant my-app --mode prod --domain example.com --worker-counts 2,3,1
```

--------------------------------

### Assign Permission Sets Before Installation

Source: https://github.com/flxbl-io/docs-sfp/blob/main/building-artifacts/configuring-installation-behaviour-of-a-package/permissionset-assignment.md

Use `assignPermSetsPreDeployment` to assign permission sets that are already present in the target org before installing an artifact. This ensures the deployment user has the required access prior to the installation process.

```json
{
      "path": "src/health-cloud",
      "package": "health-cloud",
      "versionName": "health-cloud-1.0",
      "versionNumber": "1.0.0.0",
      "assignPermSetsPreDeployment": [
        "HealthCloudFoundation",
        "HealthCloudSocialDeterminants",
        "HealthCloudAppointmentManagement",
        "HealthCloudVideoCalls",
        "HealthCloudUtilizationManagement",
        "HealthCloudMemberServices",
        "HealthCloudAdmin",
        "HealthCloudApi",
        "HealthCloudLimited",
        "HealthCloudPermissionSetLicense",
        "HealthCloudStandard",
        "HealthcareAssociatedInfectionDiseaseGroupAccess"
      ]
    }
```

--------------------------------

### `@flxbl-io/sfp pool prepare`

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/advanced/pool.md

Prepares a pool of scratch orgs with all packages installed upfront for optimized change validation.

```APIDOC
## `@flxbl-io/sfp pool prepare`

### Description
Prepare a pool of scratchorgs with all the packages upfront, so that any incoming change can be validated in an optimized manner.

### Method
CLI Command

### Usage
`@flxbl-io/sfp pool prepare -v <value> [-f <value>] [--npmrcpath <value>] [--keys <value>] [-g <value>] [--loglevel trace|debug|info|warn|error|fatal|TRACE|DEBUG|INFO|WARN|ERROR|FATAL]`

### Flags
#### `-v, --targetdevhubusername` (required)
Username or alias of the Dev Hub org.

#### `-f, --poolconfig`
[default: config/poolconfig.json] The path to the configuration file for creating a pool of scratch orgs.

#### `--npmrcpath`
Path to .npmrc file used for authentication to a npm registry when using npm based artifacts. If left blank, defaults to home directory.

#### `--keys`
Keys to be used while installing any managed package dependencies. Required format is a string of key-value pairs separated by spaces e.g. packageA:pw123 packageB:pw123 packageC:pw123.

#### `-g, --logsgroupsymbol`
Symbol used by CICD platform to group/collapse logs in the console. Provide an opening group, and an optional closing group symbol.

#### `--loglevel`
[default: info] logging level for this command invocation.
<options: trace|debug|info|warn|error|fatal|TRACE|DEBUG|INFO|WARN|ERROR|FATAL>

### Aliases
`$ @flxbl-io/sfp orchestrator prepare`
`$ @flxbl-io/sfp prepare`

### Examples
```bash
$ sfp prepare -f config/mypoolconfig.json  -v <devhub>
```
```

--------------------------------

### Disable Replacements During Install

Source: https://github.com/flxbl-io/docs-sfp/blob/main/installing-an-artifact/string-replacements-during-install.md

Use the --no-replacements flag to skip all string replacements when installing an artifact.

```bash
sfp install --targetorg dev --artifactdir artifacts --no-replacements
```

--------------------------------

### Sandbox Registration Details

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/environments/jit-sandbox.md

Example output showing the details of a JIT sandbox registration, highlighting that no credentials are stored.

```text
Sandbox Registration:
├── username: admin@production--uat.sandbox.com
├── is_jit_registration: true
├── parent_production_username: admin@production.com
└── sfdx_auth_url_encrypted: NULL  (no stored credentials)
```

--------------------------------

### Skip Installation Configuration

Source: https://github.com/flxbl-io/docs-sfp/blob/main/releasing-artifacts/release-definitions.md

Determines whether to skip artifact installation if the same version is already present in the target org.

```yaml
skipIfAlreadyInstalled: true
```

--------------------------------

### Example: Update tenant 'my-tenant' without backup

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/update.md

Demonstrates updating services for 'my-tenant' while skipping the backup process.

```bash
sfp server update --tenant my-tenant --skip-backup
```

--------------------------------

### Example Workflow with Custom Tags

Source: https://github.com/flxbl-io/docs-sfp/blob/main/metrics/custom-metrics.md

Demonstrates configuring organizational tags and then running sfp commands, showing how tags are automatically included in metrics. Command-specific tags can override custom tags.

```bash
# Configure organizational tags
sfp config set custom-tag.team devops
sfp config set custom-tag.environment staging
sfp config set custom-tag.cost-center engineering

# Run any sfp command - tags are automatically included
sfp build --branch main
# Metrics sent: sfpowerscripts.build.scheduled
# Tags: team=devops, environment=staging, cost-center=engineering, branch=main

sfp release --environment uat
# Metrics sent: sfpowerscripts.release.scheduled
# Tags: team=devops, environment=staging, cost-center=engineering, env=uat
```

--------------------------------

### Start Tenant Services in Daemon Mode

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/start.md

Starts the services for a specified tenant and runs the server in the background (detached).

```bash
sfp server start --tenant my-app --daemon
```

--------------------------------

### Install sfp-pro on RHEL/Fedora/CentOS

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/install-sfp/install-sfp-pro.md

Use rpm or yum to install the sfp-pro RPM package. Ensure you have the correct RPM filename.

```bash
sudo rpm -i sfp-pro_*.rpm
```

```bash
sudo yum install sfp-pro_*.rpm
```

--------------------------------

### Initialize SFP Server Instance

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/init.md

Initializes a new SFP server instance. Use the `--tenant` flag to specify the tenant name. Other flags allow customization of mode, domain, worker counts, base directory, secrets provider, and logging level.

```bash
sfp server init --tenant <value> [--mode dev|prod] [--domain <value>] 
    [--worker-counts <value>] [--base-dir <value>] [--secrets-provider 
    custom|infisical] [--infisical-token <value>] [--infisical-workspace 
    <value>] [--interactive] [--force] [--config-file <value>] [--loglevel
    trace|debug|info|warn|error|fatal|TRACE|DEBUG|INFO|WARN|ERROR|FATAL]
```

--------------------------------

### Create Environment - Basic

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/environments/README.md

Use this command to create a new environment with essential details like repository, name, category, branch, and target username.

```bash
sfp server environment create \
  --repository myorg/salesforce-app \
  --name UAT \
  --category test \
  --branch release/v2.0 \
  --description "User Acceptance Testing environment" \
  --targetusername admin@uat.sandbox.com
```

--------------------------------

### Dashboard JSON Schema Example

Source: https://github.com/flxbl-io/docs-sfp/blob/main/development/running-apex-tests.md

An example of the comprehensive test execution report structure provided in the dashboard JSON format.

```json
{
  "environment": "dev",
  "timestamp": "2025-11-24T10:30:00.000Z",
  "duration": 125000,
  "testExecutionTime": 120000,
  "commandTime": 115000,
  "repository": "https://github.com/myorg/myrepo",
  "commitSha": "abc123def",
  "branch": "main",

  "summary": {
    "totalTests": 150,
    "passed": 145,
    "failed": 5,
    "skipped": 0,
    "passingRate": 96.67,
    "overallCoverage": 82.5,
    "coveredLines": 8250,
    "totalLines": 10000,
    "outcome": "Failed"
  },

  "coverage": {
    "overallCoverage": 82.5,
    "totalLines": 10000,
    "coveredLines": 8250,
    "classes": [
      {
        "name": "AccountService",
        "id": "01p...",
        "coverage": 95.5,
        "totalLines": 200,
        "coveredLines": 191,
        "status": "pass"
      }
    ],
    "uncoveredClasses": ["LegacyHelper"],
    "belowThreshold": [
      {
        "name": "OldProcessor",
        "coverage": 65.0,
        "threshold": 75
      }
    ]
  },

  "testCases": [
    {
      "id": "07M...",
      "name": "AccountService.testCreateAccount",
      "className": "AccountService",
      "methodName": "testCreateAccount",
      "time": 250,
      "status": "passed"
    }
  ],

  "topFailingTests": [
    {
      "name": "ContactTest.testValidation",
      "className": "ContactTest",
      "methodName": "testValidation",
      "failureMessage": "System.AssertException: Expected 5, but got 3"
    }
  ],

  "metadata": {
    "testRunId": "707...",
    "orgId": "00D...",
    "username": "dev@example.com",
    "package": "sales-core",
    "testLevel": "RunAllTestsInPackage"
  }
}
```

--------------------------------

### Override Replacements During Install

Source: https://github.com/flxbl-io/docs-sfp/blob/main/installing-an-artifact/string-replacements-during-install.md

Use the --replacementsoverride flag to specify a custom YAML file for string replacement configurations during installation.

```bash
sfp install --targetorg dev --artifactdir artifacts --replacementsoverride custom-replacements.yml
```

--------------------------------

### Install Artifacts to Devhub

Source: https://github.com/flxbl-io/docs-sfp/blob/main/installing-an-artifact/overview.md

Use this command to install a set of artifacts to the devhub org. Ensure the artifacts are located in the specified directory.

```bash
sfp install -u devhub --artifactdir artifacts
```

--------------------------------

### Check sfp Version

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/install-sfp/install-sfp-community-edition.md

Verifies the installed sfp version and provides system details. This command is useful after installation to confirm it was successful.

```bash
sfp --version
```

```text
@flxbl-io/sfp/37.0.0 darwin-arm64 node-v20.3.1
```

--------------------------------

### External Dependencies Example

Source: https://github.com/flxbl-io/docs-sfp/blob/main/development/dependency-management/shrink-dependencies.md

An example of configuring an external dependency for 'trigger-framework' using its subscriber package version ID and the latest version.

```json
{
  "plugins": {
    "sfp": {
      "externalDependencyMap": {
        "trigger-framework": [
          {
            "package": "0H1000XRTCam",
            "versionNumber": "1.0.3.LATEST"
          }
        ]
      }
    }
  }
}
```

--------------------------------

### Install an Artifact to a Target Org

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/build-and-install-an-artifact.md

Execute this command after authenticating your Salesforce CLI to a target org. It installs the generated artifact into the specified organization.

```bash
sfp install -o <TargetOrgAlias/TargetOrgUsername>
```

--------------------------------

### Install Package Skipping Tests

Source: https://github.com/flxbl-io/docs-sfp/blob/main/development/development-workflow.md

Install a package to the target org while skipping tests for a faster deployment. Useful when tests have already been validated.

```bash
# Install with skip testing for faster deployment
sfp install --target-org my-feature-org \
  --artifacts artifacts \
  --skipifalreadyinstalled
```

--------------------------------

### Start Tenant Services with Daemon and No Browser

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/start.md

Starts the services for a specified tenant in daemon mode (background) and disables automatic browser opening.

```bash
sfp server start --tenant my-app --daemon --no-browser
```

--------------------------------

### Standard Output Example

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/releasedefinition.md

Illustrates the expected output format when generating a release definition to standard output.

```text
Generating release definition: MyRelease
Git reference: HEAD (abc123def456)
Branch: main
Config file: config/release.yml

Analyzing artifacts...
✓ Found 12 artifacts with git tags
✓ core-package: v1.2.3
✓ auth-module: v2.0.1
✓ ui-components: v3.1.0
...

Creating release definition...
✓ Release definition created

Publishing to server...
✓ Published successfully

Release Definition: MyRelease
ID: rel_abc123
Status: Published
URL: https://sfp.example.com/releases/rel_abc123
```

--------------------------------

### Installation Output with Replacements

Source: https://github.com/flxbl-io/docs-sfp/blob/main/installing-an-artifact/string-replacements-during-install.md

This output indicates that string replacements are being applied during the installation process, detailing the number of replacements and files modified for a specific environment.

```bash
Text replacements for org alias dev (sandbox)
Total replacement configs 3
Modified APIService.cls with 2 replacements
Modified ConfigService.cls with 1 replacements
Replacements summary: 3 replacements in 2 files using dev environment
```

--------------------------------

### Validate sfp Installation with Commands

Source: https://github.com/flxbl-io/docs-sfp/blob/main/getting-started/install-sfp/install-sfp-community-edition.md

Lists all available sfp commands and their summaries. Use this to confirm that the sfp CLI is functional and to explore its capabilities.

```bash
sfp commands
```

--------------------------------

### Install Artifacts to Target Org

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/core/install.md

Installs artifacts from a specified directory to a target org. Use the `-o` flag for the target org username or alias.

```bash
sfp install -o <username>
```

```bash
sfp install -o <username> --runtests
```

--------------------------------

### Example Script Invocation

Source: https://github.com/flxbl-io/docs-sfp/blob/main/validating-a-change/validation-scripts.md

Scripts receive context file path, target org username, and hub org username as arguments.

```bash
# Example script invocation:
./scripts/pre-validate.sh /tmp/sfp-validate-pre-1234567890.json scratch-org-user@example.com devhub@example.com
```

--------------------------------

### Troubleshoot Workers Not Starting

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/scale.md

Check logs for critical worker errors and verify resource availability. This helps diagnose issues preventing workers from starting.

```bash
# Check logs for errors
sfp server logs --tenant my-app --service critical-worker --tail 100
```

```bash
# Verify resources
sfp server health --detailed
```

--------------------------------

### Registering Production and Sandbox Orgs

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/environments/jit-sandbox.md

This bash script demonstrates the process for registering a production org and then a sandbox org. It first logs into the production org and registers it, then registers the sandbox, specifying the production username for JIT authentication.

```bash
# Register the production org first
sf org login web --alias production
sfp server org register --targetusername production

# Then register the sandbox
sfp server org register-sandbox \
  --sandboxname uat \
  --productionusername admin@production.com
```

--------------------------------

### Create a new SFP server environment

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/environment.md

Use this command to create a new environment, specifying its name, type, and optionally a description, SFDX auth URL, or repository. Authentication can be handled via email or an application token.

```bash
sfp server environment create --name production --type production
```

```bash
sfp server environment create --name staging --type staging --description "Staging environment for UAT"
```

```bash
sfp server environment create --name dev-sandbox --type sandbox --sfdx-auth-url force://...
```

```bash
sfp server environment create --name qa-env --type sandbox --repository myorg/myrepo
```

--------------------------------

### Create Environment - With Metadata and Tags

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/environments/README.md

This command demonstrates creating an environment with additional metadata and tags for better organization and tracking. It includes critical and monitored tags, and JSON metadata for region and SLA.

```bash
sfp server environment create \
  --repository myorg/salesforce-app \
  --name Production \
  --category release \
  --branch main \
  --description "Production environment" \
  --targetusername admin@production.com \
  --tags "critical,monitored" \
  --metadata '{"region": "US-WEST", "sla": "99.9%"}'
```

--------------------------------

### Custom Script for Artifact Download (Artifactory Example)

Source: https://github.com/flxbl-io/docs-sfp/blob/main/releasing-artifacts/patching-releases.md

Example script to download artifacts from Artifactory. It uses curl for downloading and then extracts the zip file.

```bash
# Example: Download from Artifactory
curl -u ${ARTIFACTORY_USER}:${ARTIFACTORY_TOKEN} \
  -O ${TARGET_DIR}/${PACKAGE_NAME}.zip \
  https://artifactory.company.com/sfp-artifacts/${PACKAGE_NAME}/${VERSION}/${PACKAGE_NAME}.zip
unzip ${TARGET_DIR}/${PACKAGE_NAME}.zip -d ${TARGET_DIR}/${PACKAGE_NAME}
```

--------------------------------

### Token Management Workflow with SFP CLI

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/application-token.md

Demonstrates a typical workflow for managing application tokens using the SFP CLI, including creation, listing, and revocation.

```bash
# 1. Create token for CI/CD
sfp server application-token create --name "Production CI" --expires-in 90

# 2. List and monitor tokens
sfp server application-token list

# 3. Revoke when no longer needed
sfp server application-token revoke --id tok_abc123
```

--------------------------------

### Initialize Sandbox Pools

Source: https://github.com/flxbl-io/docs-sfp/blob/main/environment-management/pools/sandbox-pools/README.md

Use this command to set up sandbox pools based on a configuration file. Specify the configuration file path, your Dev Hub alias, and the repository owner/name.

```bash
sfp pool sandbox init -f <path/to/config-file> -v <devhub-alias> -r <owner/repo>
```

--------------------------------

### Query artifacts installed in a target org

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/advanced/artifacts.md

Fetch details about artifacts that have been installed in a specified Salesforce org. The target username is required, and output can be formatted as JSON.

```bash
sfp artifacts:query -o <target_org>
```

--------------------------------

### List Pool Instances (sfp-pro)

Source: https://github.com/flxbl-io/docs-sfp/blob/main/development/development-workflow.md

Lists available instances (scratch orgs or sandboxes) from a server-managed pool. Requires repository and tag information.

```bash
sfp server pool instance list \
  --repository myorg/myrepo \
  --tag dev-pool
```

--------------------------------

### Start Tenant Services with AWS Secrets Manager

Source: https://github.com/flxbl-io/docs-sfp/blob/main/cli-reference/server/start.md

Starts the services for a specified tenant, integrating directly with AWS Secrets Manager, specifying the AWS region.

```bash
sfp server start --tenant my-app --secrets-provider aws-secretsmanager --aws-region us-east-1
```