gem-hunter

OpenFeature is an open specification that provides a vendor-agnostic, community-driven API for feature flagging that works with your favorite feature flag management tool or in-house solution.

The OpenFeature CLI is a command-line tool designed to improve the developer experience when working with feature flags. It helps developers manage feature flags consistently across different environments and programming languages by providing powerful utilities for code generation, flag validation, and more.

The CLI bridges the gap between feature flag management systems and your application code by generating strongly typed flag accessors from a flag manifest. This approach provides:

• Type Safety: Generate strongly-typed flag accessors for your preferred language
• Developer Experience: Reduce errors and improve IDE autocomplete support
• Language Support: Generate code for TypeScript, JavaScript, React, Go, C#, and more

The OpenFeature CLI can be installed using a shell command. This method is suitable for most Unix-like operating systems.

curl -fsSL https://openfeature.dev/scripts/install_cli.sh | sh

The OpenFeature CLI is available as a Docker image in the GitHub Container Registry.

You can run the CLI in a Docker container using the following command:

docker run -it -v $(pwd):/local -w /local ghcr.io/open-feature/cli:latest

If you have Go >= 1.25 installed, you can install the CLI using the following command:

go install github.com/open-feature/cli/cmd/openfeature@latest

Download the appropriate pre-built binary from the releases page.

1. Create a flag manifest file in your project root:

cat > flags.json << EOL
{
  "$schema": "https://raw.githubusercontent.com/open-feature/cli/refs/heads/main/schema/v0/flag-manifest.json",
  "flags": {
    "enableMagicButton": {
      "flagType": "boolean",
      "defaultValue": false,
      "description": "Activates a special button that enhances user interaction with magical, intuitive functionalities."
    }
  }
}
EOL

2. Generate code for your preferred language:

openfeature generate react

See here for all available options.

3. View the generated code:

cat openfeature.ts

Congratulations! You have successfully generated your first strongly typed flag accessors. You can now use the generated code in your application to access the feature flags. This is just scratching the surface of what the OpenFeature CLI can do. For more advanced usage, read on!

The OpenFeature CLI provides the following commands:

Initialize a new flag manifest in your project.

openfeature init

This command creates a flags.json file in your current directory with the proper schema reference. You can customize the manifest path using configuration options.

See here for all available options.

Manage flag manifest files with subcommands for adding, listing, and deleting flags.

# Add a new flag interactively
openfeature manifest add

# Add a boolean flag
openfeature manifest add new-feature --default-value false

# Add a string flag with description
openfeature manifest add welcome-message \
  --type string \
  --default-value "Hello!" \
  --description "Welcome message for users"

# List all flags in the manifest
openfeature manifest list

# Delete a flag from the manifest
openfeature manifest delete old-feature

The manifest command provides:

• add: Add new flags to your manifest file
• list: Display all flags with their configuration
• delete: Remove flags from your manifest file

See here for all available options.

Compare two feature flag manifests and display the differences.

# Compare your local manifest against another
openfeature compare --against production-flags.json

# Compare with different output formats
openfeature compare --against other.json --output json
openfeature compare --against other.json --output yaml
openfeature compare --against other.json --output flat

Output formats:

• tree: Hierarchical tree view (default)
• flat: Simple flat list
• json: JSON format
• yaml: YAML format

See here for all available options.

Generate strongly typed flag accessors for your project.

# List available languages
openfeature generate

# Generate for a specific language
openfeature generate typescript

# With custom output directory
openfeature generate typescript --output ./src/flags

Supported Languages:

See here for all available options.

NOTE: Angular generated code requires @openfeature/angular-sdk version 1.1.0 or newer.

Fetch feature flag configurations from a remote source.

# Pull flags from a remote API
openfeature pull --flag-source-url https://api.example.com

# With authentication
openfeature pull --flag-source-url https://api.example.com --auth-token secret-token

# Pull from a JSON file URL
openfeature pull --flag-source-url https://example.com/flags.json

The pull command supports:

• HTTP/HTTPS endpoints implementing the OpenFeature Manifest Management API
• Direct JSON/YAML file URLs
• Authentication via bearer tokens

See here for all available options.

Push local flag configurations to a remote flag management service.

# Push flags to a remote API
openfeature push --flag-source-url https://api.example.com --auth-token secret-token

# Dry run to preview changes
openfeature push --flag-source-url https://api.example.com --dry-run

The push command intelligently:

• Fetches existing flags from the remote
• Compares local flags with remote flags
• Creates new flags that don't exist remotely
• Updates existing flags that have changed

See here for all available options.

Print the version number of the OpenFeature CLI.

openfeature version

See here for all available options.

The flag manifest is a JSON file that defines your feature flags and their properties. It serves as the source of truth for your feature flags and is used by the CLI to generate strongly typed accessors. The manifest file should be named flags.json and placed in the root of your project.

The flag manifest file should follow the JSON schema with the following properties:

• $schema - The URL of the JSON schema for validation
• flags - An object containing the feature flags
  • flagKey - A unique key for the flag
    • description - A description of what the flag does
    • type - The type of the flag (boolean, string, number, object)
    • defaultValue - The default value of the flag

{
  "$schema": "https://raw.githubusercontent.com/open-feature/cli/refs/heads/main/schema/v0/flag-manifest.json",
  "flags": {
    "uniqueFlagKey": {
      "description": "Description of what this flag does",
      "type": "boolean|string|number|object",
      "defaultValue": "default-value",
    }
  }
}

The OpenFeature CLI supports synchronizing flags with remote flag management services through a standardized OpenAPI-based approach. This enables teams to:

• Pull flags from centralized flag management systems
• Push flags back to maintain consistency across environments
• Integrate with any service that implements the Manifest Management API

The CLI uses an OpenAPI-driven architecture for remote operations:

1. Standardized API: All remote operations conform to the Manifest Management API OpenAPI specification
2. Type-Safe Clients: Generated clients provide compile-time safety and better IDE support
3. Provider Agnostic: Any service implementing the API specification can integrate with the CLI

For detailed information about implementing or extending the OpenAPI client pattern, see the OpenAPI Client Pattern documentation.

If you're building a flag management service that needs to integrate with the OpenFeature CLI, implement the endpoints defined in the sync.yaml specification:

• GET /openfeature/v0/manifest - Retrieve the project manifest
• POST /openfeature/v0/manifest/flags - Create new flags
• PUT /openfeature/v0/manifest/flags/{key} - Update existing flags
• DELETE /openfeature/v0/manifest/flags/{key} - Archive/delete flags

The OpenFeature CLI uses an optional configuration file to override default settings and customize behavior. This file can be in JSON or YAML format and should be named either .openfeature.json or .openfeature.yaml.

# Example .openfeature.yaml
manifest: "flags/manifest.json" # Overrides the default manifest path
generate:
  output: "src/flags" # Overrides the default output directory
  # Any language-specific options can be specified here
  # For example, for React:
  react:
    output: "src/flags/react" # Overrides the default React output directory
  # For Go:
  go:
    package: "github.com/myorg/myrepo/flags" # Overrides the default Go package name
    output: "src/flags/go" # Overrides the default Go output directory

The CLI uses a layered approach to configuration, allowing you to override settings at different levels. The configuration is applied in the following order:

flowchart LR
  default("Default Config")
  config("Config File")
  args("Command Line Args")
  default --> config
  config --> args

• GitHub Repository: open-feature/cli
• CNCF Slack: Join the conversation in the #openfeature and #openfeature-cli channel
• Regular Meetings: Attend our community calls
• GitHub Issues: Report bugs or request features in our issue tracker
• Social Media:
  • Twitter: @openfeature
  • LinkedIn: OpenFeature

For more information, visit our community page.

• Give this repo a ⭐️!
• Share your experience and contribute back to the project

Made with contrib.rocks.