@etus/bhono-app 0.1.1

package/templates/base/.claude/skills/wrangler/resources/enviroments.md

@@ -0,0 +1,416 @@
+---
+title: Environments · Cloudflare Workers docs
+description: Use environments to create different configurations for the same
+  Worker application.
+lastUpdated: 2025-11-28T09:56:31.000Z
+chatbotDeprioritize: false
+source_url:
+  html: https://developers.cloudflare.com/workers/wrangler/environments/
+  md: https://developers.cloudflare.com/workers/wrangler/environments/index.md
+---
+
+Wrangler allows you to use environments to create different configurations for the same Worker application. Environments are configured in the Worker's [Wrangler configuration file](https://developers.cloudflare.com/workers/wrangler/configuration/).
+
+When you create an environment, Cloudflare effectively creates a new Worker with the name `<top-level-name>-<environment-name>`. For example, a Worker project named `my-worker` with an environment `dev` would deploy as a Worker named `my-worker-dev`.
+
+Review the following environments flow:
+
+1. Create a Worker, named `my-worker` for example.
+
+2. Create an environment, for example `dev`, in the Worker's [Wrangler configuration file](https://developers.cloudflare.com/workers/wrangler/configuration/), by adding a `[env.<ENV_NAME>]` section.
+
+   - wrangler.jsonc
+
+     ```jsonc
+     {
+     	"name": "my-worker",
+     	"env": {
+     		"<ENV_NAME>": {
+     			// environment-specific configuration goes here
+     		}
+     	}
+     }
+     ```
+
+   - wrangler.toml
+
+     ```toml
+     name = "my-worker"
+
+
+     [env]
+     "<ENV_NAME>" = { }
+     ```
+
+3. You can configure the `dev` environment with different values to the top-level environment. Refer [here](https://developers.cloudflare.com/workers/wrangler/configuration/#environments) for how different options are inherited - or not inherited - between environments. For example, to set a different route for a Worker in the `dev` environment:
+
+   - wrangler.jsonc
+
+     ```jsonc
+     {
+     	"$schema": "./node_modules/wrangler/config-schema.json",
+     	"name": "your-worker",
+     	"route": "example.com",
+     	"env": {
+     		"dev": {
+     			"route": "dev.example.com"
+     		}
+     	}
+     }
+     ```
+
+   - wrangler.toml
+
+     ```toml
+     name = "your-worker"
+     route = "example.com"
+
+
+     [env.dev]
+     route = "dev.example.com"
+     ```
+
+4. Environments are used with the `--env` or `-e` flag on Wrangler commands. For example, you can develop the Worker in the `dev` environment by running `npx wrangler dev -e=dev`, and deploy it with `npx wrangler deploy -e=dev`.
+
+   Alternatively, you can use the [`CLOUDFLARE_ENV` environment variable](https://developers.cloudflare.com/workers/wrangler/system-environment-variables/#supported-environment-variables) to select the active environment. For example, `CLOUDFLARE_ENV=dev npx wrangler deploy` will deploy to the `dev` environment. The `--env` command line argument takes precedence over the `CLOUDFLARE_ENV` environment variable.
+
+   Note
+
+   If you're using the [Cloudflare Vite plugin](https://developers.cloudflare.com/workers/vite-plugin/), you select the environment at dev or build time via the `CLOUDFLARE_ENV` environment variable rather than the `--env` flag. Otherwise, environments are defined in your Worker config file as usual. For more detail on using environments with the Cloudflare Vite plugin, refer to the [plugin documentation](https://developers.cloudflare.com/workers/vite-plugin/reference/cloudflare-environments/).
+
+## Non-inheritable keys and environments
+
+[Non-inheritable keys](https://developers.cloudflare.com/workers/wrangler/configuration/#non-inheritable-keys) are configurable at the top-level, but cannot be inherited by environments and must be specified for each environment.
+
+For example, [bindings](https://developers.cloudflare.com/workers/runtime-apis/bindings/) and [environment variables](https://developers.cloudflare.com/workers/configuration/environment-variables/) are non-inheritable, and must be specified per [environment](https://developers.cloudflare.com/workers/wrangler/environments/) in your [Wrangler configuration file](https://developers.cloudflare.com/workers/wrangler/configuration/).
+
+Review the following example Wrangler file:
+
+- wrangler.jsonc
+
+  ```jsonc
+  {
+  	"$schema": "./node_modules/wrangler/config-schema.json",
+  	"name": "my-worker",
+  	"vars": {
+  		"API_HOST": "example.com"
+  	},
+  	"kv_namespaces": [
+  		{
+  			"binding": "<BINDING_NAME>",
+  			"id": "<KV_NAMESPACE_ID_DEV>"
+  		}
+  	],
+  	"env": {
+  		"production": {
+  			"vars": {
+  				"API_HOST": "production.example.com"
+  			},
+  			"kv_namespaces": [
+  				{
+  					"binding": "<BINDING_NAME>",
+  					"id": "<KV_NAMESPACE_ID_PRODUCTION>"
+  				}
+  			]
+  		}
+  	}
+  }
+  ```
+
+- wrangler.toml
+
+  ```toml
+  name = "my-worker"
+
+
+  vars = { API_HOST = "example.com" }
+
+
+  kv_namespaces = [
+    { binding = "<BINDING_NAME>", id = "<KV_NAMESPACE_ID_DEV>" }
+  ]
+
+
+  [env.production]
+
+
+  vars = { API_HOST = "production.example.com" }
+
+
+  kv_namespaces = [
+    { binding = "<BINDING_NAME>", id = "<KV_NAMESPACE_ID_PRODUCTION>" }
+  ]
+  ```
+
+### Service bindings
+
+To use a [service binding](https://developers.cloudflare.com/workers/wrangler/configuration/#service-bindings) that targets a Worker in a specific environment, you need to append the environment name to the target Worker name in the `service` field. This should be in the format `<worker-name>-<environment-name>`. In the example below, we have two Workers, both with a `staging` environment. `worker-b` has a service binding to `worker-a`. Note how the `service` field in the `staging` environment points to `worker-a-staging`, whereas the top-level service binding points to `worker-a`.
+
+- wrangler.jsonc
+
+  ```jsonc
+  {
+  	"$schema": "./node_modules/wrangler/config-schema.json",
+  	"name": "worker-a",
+  	"vars": {
+  		"FOO": "<top-level-var>"
+  	},
+  	"env": {
+  		"staging": {
+  			"vars": {
+  				"FOO": "<staging-var>"
+  			}
+  		}
+  	}
+  }
+  ```
+
+- wrangler.toml
+
+  ```toml
+  name = "worker-a"
+
+
+  vars = { FOO = "<top-level-var>" }
+  [env.staging.vars]
+  FOO = "<staging-var>"
+  ```
+
+* wrangler.jsonc
+
+  ```jsonc
+  {
+  	"$schema": "./node_modules/wrangler/config-schema.json",
+  	"name": "worker-b",
+  	"services": {
+  		"binding": "<BINDING_NAME>",
+  		"service": "worker-a"
+  	},
+  	"env": {
+  		"staging": {
+  			"service": {
+  				"binding": "<BINDING_NAME>",
+  				"service": "worker-a-staging"
+  			}
+  		}
+  	}
+  }
+  ```
+
+* wrangler.toml
+
+  ```toml
+  name = "worker-b"
+
+
+  services = { binding = "<BINDING_NAME>", service = "worker-a" }
+
+
+  # Note how `service = "worker-a-staging"`
+  env.staging.service ={ binding = "<BINDING_NAME>", service = "worker-a-staging" }
+  ```
+
+### Secrets for production
+
+You may assign environment-specific [secrets](https://developers.cloudflare.com/workers/configuration/secrets/) by running the command [`wrangler secret put <KEY> -env`](https://developers.cloudflare.com/workers/wrangler/commands/#secret-put). You can also create `dotenv` type files named `.dev.vars.<environment-name>`.
+
+Like other environment variables, secrets are [non-inheritable](https://developers.cloudflare.com/workers/wrangler/configuration/#non-inheritable-keys) and must be defined per environment.
+
+### Secrets in local development
+
+Warning
+
+Do not use `vars` to store sensitive information in your Worker's Wrangler configuration file. Use secrets instead.
+
+Put secrets for use in local development in either a `.dev.vars` file or a `.env` file, in the same directory as the Wrangler configuration file.
+
+Choose to use either `.dev.vars` or `.env` but not both. If you define a `.dev.vars` file, then values in `.env` files will not be included in the `env` object during local development.
+
+These files should be formatted using the [dotenv](https://hexdocs.pm/dotenvy/dotenv-file-format.html) syntax. For example:
+
+```bash
+SECRET_KEY="value"
+API_TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"
+```
+
+Do not commit secrets to git
+
+The `.dev.vars` and `.env` files should not committed to git. Add `.dev.vars*` and `.env*` to your project's `.gitignore` file.
+
+To set different secrets for each Cloudflare environment, create files named `.dev.vars.<environment-name>` or `.env.<environment-name>`.
+
+When you select a Cloudflare environment in your local development, the corresponding environment-specific file will be loaded ahead of the generic `.dev.vars` (or `.env`) file.
+
+- When using `.dev.vars.<environment-name>` files, all secrets must be defined per environment. If `.dev.vars.<environment-name>` exists then only this will be loaded; the `.dev.vars` file will not be loaded.
+
+- In contrast, all matching `.env` files are loaded and the values are merged. For each variable, the value from the most specific file is used, with the following precedence:
+
+  - `.env.<environment-name>.local` (most specific)
+  - `.env.local`
+  - `.env.<environment-name>`
+  - `.env` (least specific)
+
+Controlling `.env` handling
+
+It is possible to control how `.env` files are loaded in local development by setting environment variables on the process running the tools.
+
+- To disable loading local dev vars from `.env` files without providing a `.dev.vars` file, set the `CLOUDFLARE_LOAD_DEV_VARS_FROM_DOT_ENV` environment variable to `"false"`.
+- To include every environment variable defined in your system's process environment as a local development variable, ensure there is no `.dev.vars` and then set the `CLOUDFLARE_INCLUDE_PROCESS_ENV` environment variable to `"true"`.
+
+---
+
+## Examples
+
+### Staging and production environments
+
+The following Wrangler file adds two environments, `[env.staging]` and `[env.production]`, to the Wrangler file. If you are deploying to a [Custom Domain](https://developers.cloudflare.com/workers/configuration/routing/custom-domains/) or [route](https://developers.cloudflare.com/workers/configuration/routing/routes/), you must provide a [`route` or `routes` key](https://developers.cloudflare.com/workers/wrangler/configuration/) for each environment.
+
+- wrangler.jsonc
+
+  ```jsonc
+  {
+  	"$schema": "./node_modules/wrangler/config-schema.json",
+  	"name": "my-worker",
+  	"route": "dev.example.com/*",
+  	"vars": {
+  		"ENVIRONMENT": "dev"
+  	},
+  	"env": {
+  		"staging": {
+  			"vars": {
+  				"ENVIRONMENT": "staging"
+  			},
+  			"route": "staging.example.com/*"
+  		},
+  		"production": {
+  			"vars": {
+  				"ENVIRONMENT": "production"
+  			},
+  			"routes": ["example.com/foo/*", "example.com/bar/*"]
+  		}
+  	}
+  }
+  ```
+
+- wrangler.toml
+
+  ```toml
+  name = "my-worker"
+  route = "dev.example.com/*"
+  vars = { ENVIRONMENT = "dev" }
+
+
+  [env.staging]
+  vars = { ENVIRONMENT = "staging" }
+  route = "staging.example.com/*"
+
+
+  [env.production]
+  vars = { ENVIRONMENT = "production" }
+  routes = [
+    "example.com/foo/*",
+    "example.com/bar/*"
+  ]
+  ```
+
+You can pass the name of the environment via the `--env` flag to run commands in a specific environment.
+
+With this configuration, Wrangler will behave in the following manner:
+
+```sh
+npx wrangler deploy
+```
+
+```sh
+Uploaded my-worker
+Published my-worker
+  dev.example.com/*
+```
+
+```sh
+npx wrangler deploy --env staging
+```
+
+```sh
+Uploaded my-worker-staging
+Published my-worker-staging
+  staging.example.com/*
+```
+
+```sh
+npx wrangler deploy --env production
+```
+
+```sh
+Uploaded my-worker-production
+Published my-worker-production
+  example.com/*
+```
+
+Any defined [environment variables](https://developers.cloudflare.com/workers/configuration/environment-variables/) (the [`vars`](https://developers.cloudflare.com/workers/wrangler/configuration/) key) are exposed as global variables to your Worker.
+
+With this configuration, the `ENVIRONMENT` variable can be used to call specific code depending on the given environment:
+
+```js
+if (ENVIRONMENT === "staging") {
+	// staging-specific code
+} else if (ENVIRONMENT === "production") {
+	// production-specific code
+}
+```
+
+### Staging environment with \*.workers.dev
+
+To deploy your code to your `*.workers.dev` subdomain, include `workers_dev = true` in the desired environment. Your Wrangler file may look like this:
+
+- wrangler.jsonc
+
+  ```jsonc
+  {
+  	"$schema": "./node_modules/wrangler/config-schema.json",
+  	"name": "my-worker",
+  	"route": "example.com/*",
+  	"env": {
+  		"staging": {
+  			"workers_dev": true
+  		}
+  	}
+  }
+  ```
+
+- wrangler.toml
+
+  ```toml
+  name = "my-worker"
+  route = "example.com/*"
+
+
+  [env.staging]
+  workers_dev = true
+  ```
+
+With this configuration, Wrangler will behave in the following manner:
+
+```sh
+npx wrangler deploy
+```
+
+```sh
+Uploaded my-worker
+Published my-worker
+  example.com/*
+```
+
+```sh
+npx wrangler deploy --env staging
+```
+
+```sh
+Uploaded my-worker
+Published my-worker
+  https://my-worker-staging.<YOUR_SUBDOMAIN>.workers.dev
+```
+
+Warning
+
+When you create a Worker via an environment, Cloudflare automatically creates an SSL certification for it. SSL certifications are discoverable and a matter of public record. Be careful when naming your environments that they do not contain sensitive information, such as, `migrating-service-from-company1-to-company2` or `company1-acquisition-load-test`.

package/templates/base/.claude/skills/wrangler/resources/extract_sections.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Script para extrair seções do conteúdo completo da documentação do Wrangler
+e criar arquivos individuais conforme o mapeamento de linhas fornecido.
+"""
+
+import re
+import os
+
+# Mapeamento de seções conforme fornecido pelo usuário
+SECTIONS = [
+    (64, 126, "how-to-run.md"),
+    (127, 188, "docs.md"),
+    (189, 220, "init.md"),
+    (221, 376, "containers.md"),
+    (377, 1220, "d1.md"),
+    (1221, 1646, "hyperdrive.md"),
+    (1647, 2588, "vectorize.md"),
+    (2589, 2750, "dev.md"),
+    (2751, 2896, "deploy.md"),
+    (2897, 2924, "delete.md"),
+    (2925, 3192, "kv-namespace.md"),
+    (3193, 3548, "kv-key.md"),
+    (3549, 3818, "kv-bulk.md"),
+    (3819, 6114, "r2-bucket.md"),
+    (6115, 6384, "r2-object.md"),
+    (6385, 6452, "r2-sql.md"),
+    (6453, 6520, "setup.md"),
+    (6521, 6827, "secret.md"),
+    (6828, 7312, "secrets-store-secret.md"),
+    (7313, 7541, "secrets-store-store.md"),
+    (7542, 8165, "workflows.md"),
+    (8166, 8265, "tail.md"),
+    (8266, 9265, "pages.md"),
+    (9266, 10239, "pipelines.md"),
+    (10240, 11489, "queues.md"),
+    (11490, 11550, "login.md"),
+    (11551, 11579, "logout.md"),
+    (11580, 11637, "whoami.md"),
+    (11638, 12195, "versions.md"),
+    (12196, 12273, "triggers.md"),
+    (12274, 12401, "deployments.md"),
+    (12402, 12429, "rollback.md"),
+    (12430, 12717, "dispatch-namespace.md"),
+    (12718, 12974, "mtls-certificate.md"),
+    (12975, 13281, "cert.md"),
+    (13282, 13329, "types.md"),
+    (13330, 13372, "telemetry.md"),
+    (13373, 13406, "check.md"),
+]
+
+def extract_section_by_header(content, section_name):
+    """Extrai uma seção baseada no header markdown"""
+    # Padrões para identificar seções
+    patterns = {
+        "how-to-run": r"## How to run Wrangler commands",
+        "docs": r"## `docs`",
+        "init": r"## `init`",
+        "containers": r"## `containers`",
+        "d1": r"## `d1`",
+        "hyperdrive": r"## `hyperdrive`",
+        "vectorize": r"## `vectorize`",
+        "dev": r"## `dev`",
+        "deploy": r"## `deploy`",
+        "delete": r"## `delete`",
+        "kv-namespace": r"## `kv namespace`",
+        "kv-key": r"## `kv key`",
+        "kv-bulk": r"## `kv bulk`",
+        "r2-bucket": r"## `r2 bucket`",
+        "r2-object": r"## `r2 object`",
+        "r2-sql": r"## r2 SQL|## `r2 sql`",
+        "setup": r"## `setup`",
+        "secret": r"## `secret`",
+        "secrets-store-secret": r"## `secrets-store secret`",
+        "secrets-store-store": r"## `secrets-store store`",
+        "workflows": r"## `workflows`",
+        "tail": r"## `tail`",
+        "pages": r"## `pages`",
+        "pipelines": r"## `pipelines`",
+        "queues": r"## `queues`",
+        "login": r"## `login`",
+        "logout": r"## `logout`",
+        "whoami": r"## `whoami`",
+        "versions": r"## `versions`",
+        "triggers": r"## `triggers`",
+        "deployments": r"## `deployments`",
+        "rollback": r"## `rollback`",
+        "dispatch-namespace": r"## dispatch namespace|## `dispatch-namespace`",
+        "mtls-certificate": r"## `mtls-certificate`",
+        "cert": r"## `cert`",
+        "types": r"## `types`",
+        "telemetry": r"## `telemetry`",
+        "check": r"## `check`",
+    }
+    
+    pattern = patterns.get(section_name)
+    if not pattern:
+        return None
+    
+    # Encontra o início da seção
+    match = re.search(pattern, content, re.IGNORECASE | re.MULTILINE)
+    if not match:
+        return None
+    
+    start_pos = match.start()
+    
+    # Encontra o próximo header de nível 2 (##) ou o fim do arquivo
+    next_header = re.search(r'\n## ', content[start_pos + 1:])
+    if next_header:
+        end_pos = start_pos + next_header.start() + 1
+        return content[start_pos:end_pos].strip()
+    else:
+        return content[start_pos:].strip()
+
+if __name__ == "__main__":
+    print("Este script precisa do conteúdo completo da documentação.")
+    print("Use o conteúdo obtido do Firecrawl para processar.")
+
+

package/templates/base/.claude/skills/wrangler/resources/process_content.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""
+Processa o conteúdo completo da documentação do Wrangler e extrai seções
+"""
+
+import re
+import os
+
+# Mapeamento de seções - nome do arquivo e padrão de header
+SECTION_MAPPING = [
+    ("how-to-run.md", r"## How to run Wrangler commands"),
+    ("docs.md", r"## `docs`"),
+    ("init.md", r"## `init`"),
+    ("containers.md", r"## `containers`"),
+    ("d1.md", r"## `d1`"),
+    ("hyperdrive.md", r"## `hyperdrive`"),
+    ("vectorize.md", r"## `vectorize`"),
+    ("dev.md", r"## `dev`"),
+    ("deploy.md", r"## `deploy`"),
+    ("delete.md", r"## `delete`"),
+    ("kv-namespace.md", r"## `kv namespace`"),
+    ("kv-key.md", r"## `kv key`"),
+    ("kv-bulk.md", r"## `kv bulk`"),
+    ("r2-bucket.md", r"## `r2 bucket`"),
+    ("r2-object.md", r"## `r2 object`"),
+    ("r2-sql.md", r"## r2 SQL|## `r2 sql`"),
+    ("setup.md", r"## `setup`"),
+    ("secret.md", r"## `secret`"),
+    ("secrets-store-secret.md", r"## `secrets-store secret`"),
+    ("secrets-store-store.md", r"## `secrets-store store`"),
+    ("workflows.md", r"## `workflows`"),
+    ("tail.md", r"## `tail`"),
+    ("pages.md", r"## `pages`"),
+    ("pipelines.md", r"## `pipelines`"),
+    ("queues.md", r"## `queues`"),
+    ("login.md", r"## `login`"),
+    ("logout.md", r"## `logout`"),
+    ("whoami.md", r"## `whoami`"),
+    ("versions.md", r"## `versions`"),
+    ("triggers.md", r"## `triggers`"),
+    ("deployments.md", r"## `deployments`"),
+    ("rollback.md", r"## `rollback`"),
+    ("dispatch-namespace.md", r"## dispatch namespace|## `dispatch-namespace`"),
+    ("mtls-certificate.md", r"## `mtls-certificate`"),
+    ("cert.md", r"## `cert`"),
+    ("types.md", r"## `types`"),
+    ("telemetry.md", r"## `telemetry`"),
+    ("check.md", r"## `check`"),
+]
+
+def extract_sections(content, output_dir):
+    """Extrai seções do conteúdo completo"""
+    lines = content.split('\n')
+    sections = {}
+    
+    # Encontra todas as seções baseadas nos headers
+    current_section = None
+    current_content = []
+    
+    for i, line in enumerate(lines, 1):
+        # Verifica se é um header de seção
+        for filename, pattern in SECTION_MAPPING:
+            if re.match(pattern, line, re.IGNORECASE):
+                # Salva seção anterior se existir
+                if current_section:
+                    sections[current_section] = '\n'.join(current_content).strip()
+                
+                # Inicia nova seção
+                current_section = filename
+                current_content = [line]
+                break
+        else:
+            # Adiciona linha ao conteúdo atual
+            if current_section:
+                current_content.append(line)
+    
+    # Salva última seção
+    if current_section:
+        sections[current_section] = '\n'.join(current_content).strip()
+    
+    # Escreve arquivos
+    for filename, section_content in sections.items():
+        filepath = os.path.join(output_dir, filename)
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(section_content)
+        print(f"✓ Criado: {filename} ({len(section_content.split(chr(10)))} linhas)")
+    
+    return sections
+
+if __name__ == "__main__":
+    print("Script de processamento criado.")
+    print("Este script precisa ser executado com o conteúdo completo da documentação.")
+
+