fastlane-plugin-charles 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fbb9bce2869ecdce4ed25d8d4c8566910c4842d841c3699f41fcbfbdd5d0550e
+  data.tar.gz: 66d7e3dd9a1de505b3ef8b3951267dacfe875f3e6a21c98131ea58039a301d51
+SHA512:
+  metadata.gz: c2448b5eb66dca95d838b146dfb3c4eb8521a105311c1a3f496d70413539b473906d090a6656773068f3a322dd972b373be789b429366484ad3c387dc6ab5ccb
+  data.tar.gz: 5f32e89226f22db3235589752212427a89d90c7a34fb434ce43b8c141249ed9a27103fb0e4e7e639df7ed4e2f4347732cf4c213efd494dfc964dcbb365f591d9

data/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-06-30
+
+### Added
+
+- `charles` action: launches Charles Proxy on macOS, generating its `.config`
+  XML at runtime from a simplified `charles.yml` (see
+  [`example/charles.yml`](example/charles.yml)) instead of requiring
+  developers to hand-edit and commit Charles's own exported XML.
+- `proxy.enable_socks` and `proxy.ssl` for controlling Charles's SOCKS proxy
+  and SSL decryption, including per-host port overrides and an
+  `include`/`exclude` form for carving hosts out of SSL decryption.
+- `recording.hosts`, using a generalized location matcher
+  (`protocol`/`host`/`port`/`path`/`query`, each optional) shared with future
+  location-based config.
+- `access_control.ip_ranges` in `charles.yml` (with an `"all"` shorthand for
+  `0.0.0.0/0`), merged at runtime with the per-developer `ip_ranges` action
+  option — CIDR notation or bare IPs (treated as `/32`).
+- `registered_name` / `registered_key` action options for Charles Proxy
+  license registration, sourced from env vars rather than committed config.
+- Automatic EULA acceptance in the generated config.
+- Clear, actionable errors (instead of raw Ruby exceptions) for common
+  `charles.yml` mistakes: a missing file, invalid YAML syntax, YAML that
+  isn't a mapping at the top level, and malformed `ip_ranges` CIDR entries.
+
+### Known limitations
+
+- Charles's `toolConfiguration` tools (Breakpoints, Rewrite, Map Remote,
+  Block/Allow List, etc.) are not yet supported — see
+  [`docs/tool-configuration.md`](docs/tool-configuration.md) for the
+  per-tool evaluation and rationale.
+
+[Unreleased]: https://github.com/jakekrog/fastlane-plugin-charles/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/jakekrog/fastlane-plugin-charles/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Jake Krog (https://github.com/jakekrog)
+
+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.

data/README.md

@@ -0,0 +1,82 @@
+# Charles `fastlane` Plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-charles)
+[![Gem Version](https://img.shields.io/gem/v/fastlane-plugin-charles.svg)](https://rubygems.org/gems/fastlane-plugin-charles)
+[![Test](https://github.com/jakekrog/fastlane-plugin-charles/actions/workflows/test.yml/badge.svg)](https://github.com/jakekrog/fastlane-plugin-charles/actions/workflows/test.yml)
+[![pre-commit](https://github.com/jakekrog/fastlane-plugin-charles/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/jakekrog/fastlane-plugin-charles/actions/workflows/pre-commit.yml)
+[![License: MIT](https://img.shields.io/github/license/jakekrog/fastlane-plugin-charles.svg)](LICENSE)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-charles`, add it to your project by running:
+
+```bash
+fastlane add_plugin charles
+```
+
+## About charles
+
+Run [Charles Proxy](https://www.charlesproxy.com/) from a fastlane lane, generating its `.config` file at runtime from a simplified YAML config (see [`example/charles.yml`](example/charles.yml)) that a team can commit and share, instead of hand-editing (and committing) Charles's own exported XML.
+
+Currently macOS only (the default `app_path` points at the standard macOS Charles install).
+
+### Options
+
+| Key | Env var | Description | Default |
+| ----- | --------- | -------------- | --------- |
+| `app_path` | `FL_CHARLES_APP_PATH` | Path to the Charles application executable | `/Applications/Charles.app/Contents/MacOS/Charles` |
+| `config_path` | `FL_CHARLES_CONFIG_PATH` | Path to a simplified Charles YAML config (see [`example/charles.yml`](example/charles.yml)) | `charles.yml` |
+| `registered_name` | `FL_CHARLES_REGISTERED_NAME` | Registered name for your Charles Proxy license | none |
+| `registered_key` | `FL_CHARLES_REGISTERED_KEY` | License key for your Charles Proxy registration | none |
+| `ip_ranges` | `FL_CHARLES_IP_RANGES` | Per-developer IP ranges permitted to access the proxy | `[]` |
+
+`registered_name` and `registered_key` are intentionally kept out of `charles.yml` since they're per-developer secrets, not shared team config — set them via env vars (or a `.env` file fastlane will load) instead of committing them. They must be provided together.
+
+`ip_ranges` works as a hybrid: the `ip_ranges` action option/env var is for ranges that only apply to one developer (e.g. their own machine), while ranges that genuinely apply to the whole team (a shared corporate subnet, or `"all"` as shorthand for `0.0.0.0/0`) belong in `charles.yml`'s `access_control.ip_ranges` instead — the two lists are merged at runtime. Each entry can be full CIDR notation (`10.0.1.20/32`) or a bare IP (`10.0.1.20`), which is treated as `/32` (that single host).
+
+See [`example/.env.example`](example/.env.example) for a template covering these env vars — copy it to `.env` (which stays gitignored) rather than committing real values.
+
+```ruby
+charles # Use default paths
+charles(app_path: "/path/to/Charles.app/Contents/MacOS/Charles")
+charles(config_path: "/path/to/charles.yml")
+charles(app_path: "/custom/path/to/Charles", config_path: "/custom/path/to/charles.yml")
+```
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+[`example/charles.yml`](example/charles.yml) shows the simplified schema this plugin generates a Charles `.config` file from at runtime.
+
+`charles.yml` doesn't yet cover Charles's `toolConfiguration` tools (Breakpoints, Rewrite, Map Remote, Block List, etc.) — see [`docs/tool-configuration.md`](docs/tool-configuration.md) for the per-tool evaluation and why that's deferred to a future release.
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```bash
+bundle exec rake
+```
+
+To automatically fix many of the styling issues, use
+
+```bash
+bundle exec rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository. See [CONTRIBUTING.md](CONTRIBUTING.md) if you'd like to open a PR, [CHANGELOG.md](CHANGELOG.md) for release history, [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) for community guidelines, and [SECURITY.md](SECURITY.md) to report a vulnerability.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/charles/actions/charles_action.rb

@@ -0,0 +1,104 @@
+require 'fastlane/action'
+require 'fastlane_core/configuration/config_item'
+require 'tmpdir'
+require_relative '../helper/charles_helper'
+
+module Fastlane
+  module Actions
+    class CharlesAction < Action
+      def self.run(params)
+        charles_app_path = params[:app_path]
+        yaml_config_path = params[:config_path]
+        config_xml = Helper::CharlesHelper.generate_config_xml(
+          yaml_config_path,
+          registered_name: params[:registered_name],
+          registered_key: params[:registered_key],
+          ip_ranges: params[:ip_ranges]
+        )
+
+        Dir.mktmpdir('fastlane-charles-') do |tmp_dir|
+          charles_config_path = File.join(tmp_dir, 'charles.config')
+          File.write(charles_config_path, config_xml)
+
+          Actions.sh(charles_app_path, '-config', charles_config_path)
+        end
+      end
+
+      def self.description
+        'Run Charles HTTP proxy'
+      end
+
+      def self.authors
+        ['jakekrog']
+      end
+
+      def self.return_value
+      end
+
+      def self.details
+        'This action starts Charles Proxy, generating its .config file at runtime from a simplified YAML config (see example/charles.yml). You can specify the path to the Charles application and the YAML config either through command-line arguments or environment variables.'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :app_path,
+            env_name: 'FL_CHARLES_APP_PATH',
+            description: 'Path to Charles application executable',
+            default_value: '/Applications/Charles.app/Contents/MacOS/Charles',
+            optional: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :config_path,
+            env_name: 'FL_CHARLES_CONFIG_PATH',
+            description: 'Path to a simplified Charles YAML config (see example/charles.yml), used to generate a Charles .config file at runtime',
+            default_value: 'charles.yml',
+            optional: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :registered_name,
+            env_name: 'FL_CHARLES_REGISTERED_NAME',
+            description: 'Registered name for your Charles Proxy license',
+            optional: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :registered_key,
+            env_name: 'FL_CHARLES_REGISTERED_KEY',
+            description: 'License key for your Charles Proxy registration',
+            optional: true,
+            sensitive: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :ip_ranges,
+            env_name: 'FL_CHARLES_IP_RANGES',
+            description: 'IP ranges permitted to access the proxy, in CIDR notation or as bare IPs (treated as /32)',
+            optional: true,
+            type: Array,
+            default_value: []
+          )
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'charles # Use default paths',
+          'charles(app_path: "/path/to/Charles.app/Contents/MacOS/Charles")',
+          'charles(config_path: "/path/to/charles.yml")',
+          'charles(app_path: "/custom/path/to/Charles", config_path: "/custom/path/to/charles.yml")'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/charles/helper/charles_helper.rb

@@ -0,0 +1,247 @@
+require 'fastlane_core/ui/ui'
+require 'yaml'
+require 'rexml/document'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class CharlesHelper
+      SERIALISATION_VERSION = '2.0'.freeze
+      ACCEPTED_EULA_VERSION = '20240608'.freeze
+      DEFAULT_SSL_PORT = 443
+      DEFAULT_CIDR_PREFIX = 32
+      ALL_IP_RANGES_ALIAS = 'all'.freeze
+      ALL_IP_RANGES_CIDR = '0.0.0.0/0'.freeze
+      CIDR_PATTERN = %r{\A(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})(?:/(\d{1,2}))?\z}
+
+      # Charles's standard location matcher (used by recording, and future
+      # tools like block/allow lists) supports protocol/host/port/path/query,
+      # each optional — Charles treats a blank field as "match all values".
+      # A YAML entry is either a bare hostname string, shorthand for
+      # `{host: <string>}`, or a Hash with any subset of those keys, e.g.:
+      #   - protocol: https
+      #     host: "api.example.com"
+      #     path: "/debug"
+      LOCATION_FIELDS = %i[protocol host port path query].freeze
+
+      # Reads a simplified Charles YAML config (see example/charles.yml) and
+      # returns the equivalent Charles `.config` XML as a String.
+      #
+      # `registered_name`/`registered_key` (a Charles Proxy license) are
+      # per-developer secrets, not part of the committed YAML — they're
+      # passed in separately so they can be sourced from env vars instead.
+      #
+      # `ip_ranges` are runtime/per-developer CIDR ranges (e.g. a developer's
+      # own machine), merged with any `access_control.ip_ranges` committed in
+      # the YAML (e.g. a shared corporate subnet, or "all" for 0.0.0.0/0).
+      def self.generate_config_xml(yaml_path, registered_name: nil, registered_key: nil, ip_ranges: [])
+        config = load_config(yaml_path)
+        root = build_configuration_element(config)
+        combined_ip_ranges = merge_ip_ranges(config['access_control'] || {}, ip_ranges)
+        build_access_control_configuration(root, combined_ip_ranges)
+        build_startup_configuration(root)
+        build_registration_configuration(root, registered_name, registered_key)
+        xml_header + format_element(root)
+      end
+
+      # Loads and validates the YAML config, raising a clear UI.user_error!
+      # (instead of a raw Ruby exception) for the ways a hand-edited
+      # charles.yml commonly goes wrong: missing file, invalid YAML syntax,
+      # or valid YAML that isn't a Hash at the top level (e.g. a bare list).
+      def self.load_config(yaml_path)
+        UI.user_error!("Charles YAML config not found at #{yaml_path.inspect}") unless File.exist?(yaml_path)
+
+        config = begin
+          YAML.load_file(yaml_path)
+        rescue Psych::SyntaxError => e
+          UI.user_error!("Charles YAML config at #{yaml_path.inspect} is not valid YAML: #{e.message}")
+        end
+
+        config ||= {}
+        unless config.kind_of?(Hash)
+          UI.user_error!("Charles YAML config at #{yaml_path.inspect} must be a mapping (Hash) at the top level, got #{config.class}")
+        end
+
+        config
+      end
+
+      def self.xml_header
+        "<?xml version='1.0' encoding='UTF-8' ?>\n<?charles serialisation-version='#{SERIALISATION_VERSION}' ?>\n"
+      end
+
+      def self.build_configuration_element(config)
+        root = REXML::Element.new('configuration')
+        build_proxy_configuration(root, config['proxy'] || {})
+        build_recording_configuration(root, config['recording'] || {})
+        root
+      end
+
+      def self.format_element(element)
+        output = ''
+        formatter = REXML::Formatters::Pretty.new(2)
+        formatter.compact = true
+        formatter.write(element, output)
+        output
+      end
+
+      def self.build_proxy_configuration(root, proxy)
+        proxy_el = root.add_element('proxyConfiguration')
+        proxy_el.add_element('enableSOCKSProxy').text = proxy.fetch('enable_socks', true).to_s
+
+        ssl_includes, ssl_excludes = normalize_ssl_config(proxy['ssl'])
+        build_ssl_locations(proxy_el, 'sslLocations', ssl_includes)
+        build_ssl_locations(proxy_el, 'sslExcludeLocations', ssl_excludes)
+      end
+
+      def self.build_ssl_locations(proxy_el, element_name, entries)
+        return if entries.empty?
+
+        patterns_el = proxy_el.add_element(element_name).add_element('locationPatterns')
+        entries.each do |entry|
+          host, port = normalize_ssl_entry(entry)
+          location_el = patterns_el.add_element('locationMatch').add_element('location')
+          location_el.add_element('host').text = host
+          location_el.add_element('port').text = port.to_s
+        end
+      end
+
+      def self.build_recording_configuration(root, recording)
+        record_hosts = Array(recording['hosts'])
+        return if record_hosts.empty?
+
+        patterns_el = root.add_element('recordingConfiguration')
+                          .add_element('recordHosts')
+                          .add_element('locationPatterns')
+        record_hosts.each do |entry|
+          match_el = patterns_el.add_element('locationMatch')
+          build_location_element(match_el, normalize_location_entry(entry))
+        end
+      end
+
+      def self.build_access_control_configuration(root, ip_ranges)
+        ip_ranges = Array(ip_ranges)
+        return if ip_ranges.empty?
+
+        ip_ranges_el = root.add_element('accessControlConfiguration').add_element('ipRanges')
+        ip_ranges.each do |cidr|
+          ip_octets, mask_octets = parse_cidr(cidr)
+          range_el = ip_ranges_el.add_element('ipRange')
+          ip_el = range_el.add_element('ip')
+          ip_octets.each { |octet| ip_el.add_element('int').text = octet.to_s }
+          mask_el = range_el.add_element('mask')
+          mask_octets.each { |octet| mask_el.add_element('int').text = octet.to_s }
+        end
+      end
+
+      def self.build_startup_configuration(root)
+        root.add_element('startupConfiguration').add_element('acceptedEulaVersion').text = ACCEPTED_EULA_VERSION
+      end
+
+      def self.build_registration_configuration(root, registered_name, registered_key)
+        return if registered_name.nil? && registered_key.nil?
+
+        if registered_name.nil? || registered_key.nil?
+          UI.user_error!('Both registered_name and registered_key must be provided to register Charles')
+        end
+
+        registration_el = root.add_element('registrationConfiguration')
+        registration_el.add_element('name').text = registered_name
+        registration_el.add_element('key').text = registered_key
+      end
+
+      # `proxy.ssl` is either a plain list (shorthand for an include-only
+      # list, matching Charles's own default), or a Hash with `include`/
+      # `exclude` keys for the rarer case where some hosts need to be
+      # carved out of SSL decryption, e.g.:
+      #   ssl:
+      #     include:
+      #       - "*.example.com"
+      #     exclude:
+      #       - "exclude-ssl-host.com"
+      def self.normalize_ssl_config(ssl)
+        if ssl.kind_of?(Hash)
+          [Array(ssl['include']), Array(ssl['exclude'])]
+        else
+          [Array(ssl), []]
+        end
+      end
+
+      # Each `proxy.ssl` (include/exclude) entry is either a bare hostname
+      # string (assumed to use the default SSL port), or a `{host:, port:}`
+      # Hash for the rare case where a host needs a non-standard port, e.g.:
+      #   - host: "internal.example.com"
+      #     port: 8443
+      def self.normalize_ssl_entry(entry)
+        if entry.kind_of?(Hash)
+          [entry['host'] || entry[:host], entry['port'] || entry[:port] || DEFAULT_SSL_PORT]
+        else
+          [entry, DEFAULT_SSL_PORT]
+        end
+      end
+
+      def self.normalize_location_entry(entry)
+        return { host: entry } unless entry.kind_of?(Hash)
+
+        LOCATION_FIELDS.each_with_object({}) do |field, attrs|
+          value = entry[field.to_s] || entry[field]
+          attrs[field] = value unless value.nil?
+        end
+      end
+
+      # Only emits the sub-elements a location entry actually specifies,
+      # matching how Charles itself omits blank ("match all") fields.
+      def self.build_location_element(parent, attrs)
+        location_el = parent.add_element('location')
+        LOCATION_FIELDS.each do |field|
+          value = attrs[field]
+          next if value.nil?
+
+          location_el.add_element(field.to_s).text = value.to_s
+        end
+        location_el
+      end
+
+      # Combines `access_control.ip_ranges` committed in the YAML with
+      # `ip_ranges` passed in at runtime, normalizing the "all" alias to
+      # 0.0.0.0/0 and removing duplicates.
+      def self.merge_ip_ranges(access_control, runtime_ip_ranges)
+        committed = Array(access_control['ip_ranges'])
+        (committed + Array(runtime_ip_ranges)).map { |entry| normalize_ip_range(entry) }.uniq
+      end
+
+      def self.normalize_ip_range(entry)
+        entry.to_s.strip.downcase == ALL_IP_RANGES_ALIAS ? ALL_IP_RANGES_CIDR : entry
+      end
+
+      # Converts a CIDR string (e.g. "10.0.1.20/32") into the ip/mask octet
+      # arrays Charles's accessControlConfiguration expects. A bare IP with
+      # no "/prefix" (e.g. "10.0.1.20") is treated as /32, i.e. that single
+      # host.
+      def self.parse_cidr(cidr)
+        ip_octets, prefix_length = validate_cidr!(cidr)
+
+        mask_int = prefix_length.zero? ? 0 : (0xFFFFFFFF << (32 - prefix_length)) & 0xFFFFFFFF
+        mask_octets = [24, 16, 8, 0].map { |shift| (mask_int >> shift) & 0xFF }
+
+        [ip_octets, mask_octets]
+      end
+
+      # Matches `cidr` against CIDR_PATTERN and returns the [ip_octets,
+      # prefix_length], raising a clear UI.user_error! for any of the ways
+      # a hand-typed ip_ranges entry commonly goes wrong.
+      def self.validate_cidr!(cidr)
+        match = CIDR_PATTERN.match(cidr.to_s)
+        UI.user_error!("Invalid ip_ranges entry #{cidr.inspect}: expected CIDR notation (e.g. \"10.0.1.20/32\") or a bare IP") unless match
+
+        ip_octets = match.captures[0, 4].map(&:to_i)
+        UI.user_error!("Invalid ip_ranges entry #{cidr.inspect}: each octet must be 0-255") if ip_octets.any? { |octet| octet > 255 }
+
+        prefix_length = (match[5] || DEFAULT_CIDR_PREFIX.to_s).to_i
+        UI.user_error!("Invalid ip_ranges entry #{cidr.inspect}: prefix must be 0-32") if prefix_length > 32
+
+        [ip_octets, prefix_length]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/charles/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module Charles
+    VERSION = "0.1.0"
+  end
+end

data/lib/fastlane/plugin/charles.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/charles/version'
+
+module Fastlane
+  module Charles
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::Charles.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-charles
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jake Krog
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Runs Charles Proxy from a fastlane lane, generating its .config file
+  at runtime from a simplified YAML config that a team can commit and share, instead
+  of hand-editing the XML Charles itself exports.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/fastlane/plugin/charles.rb
+- lib/fastlane/plugin/charles/actions/charles_action.rb
+- lib/fastlane/plugin/charles/helper/charles_helper.rb
+- lib/fastlane/plugin/charles/version.rb
+homepage: https://github.com/jakekrog/fastlane-plugin-charles
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/jakekrog/fastlane-plugin-charles/issues
+  changelog_uri: https://github.com/jakekrog/fastlane-plugin-charles/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/jakekrog/fastlane-plugin-charles
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Run Charles HTTP proxy
+test_files: []