@zenifra/cli 0.2.3 → 0.2.5

package/bin/zenifra.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, rm, writeFile, chmod } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
@@ -13,6 +14,7 @@ const DOCS_RUNTIME_URL = `${DOCS_BASE_URL}/docs/runtime`;
 const DOCS_CREATE_HTTP_URL = `${DOCS_BASE_URL}/docs/how-use-zenifra/http/how-to-create-a-http-project-at-zenifra-via-console`;
 const DOCS_CREATE_POSTGRESQL_URL = `${DOCS_BASE_URL}/docs/how-use-zenifra/database/how-to-create-a-postgresql-project-at-zenifra-via-console`;
 const DOCS_CREATE_MARIADB_URL = `${DOCS_BASE_URL}/docs/how-use-zenifra/database/how-to-create-a-mariadb-project-at-zenifra-via-console`;
+const DOCS_CREATE_VALKEY_URL = `${DOCS_BASE_URL}/docs/managed-services/valkey`;
 const DOCS_CONFIGURATION_URL = `${DOCS_BASE_URL}/docs/configuration`;
 const DOCS_DATABASE_CONFIGURATION_URL = `${DOCS_BASE_URL}/docs/database/configuration/configuration`;
 const DOCS_PAYMENTS_URL = `${DOCS_BASE_URL}/docs/payments/payments`;
@@ -21,6 +23,56 @@ const SESSION_FILE = join(SESSION_DIR, 'session.json');
 const PROFILES_FILE = join(SESSION_DIR, 'profiles.json');
 const PROFILE_STORE_VERSION = 1;
 const DEFAULT_PROFILE_NAME = 'default';
+const DEFAULT_HTTP_TIMEOUT_MS = 30_000;
+const KNOWN_FLAG_NAMES = new Set([
+  'apiBase',
+  'branch',
+  'build',
+  'challengeToken',
+  'code',
+  'commitSha',
+  'config',
+  'count',
+  'cpu',
+  'cursor',
+  'description',
+  'direction',
+  'email',
+  'exposure',
+  'follow',
+  'from',
+  'help',
+  'image',
+  'idempotencyKey',
+  'instance',
+  'interval',
+  'json',
+  'key',
+  'limit',
+  'max',
+  'memory',
+  'min',
+  'mode',
+  'name',
+  'org',
+  'operation',
+  'page',
+  'password',
+  'paymentMode',
+  'plan',
+  'profile',
+  'project',
+  'revoke',
+  'showValues',
+  'status',
+  'timeout',
+  'to',
+  'totp',
+  'type',
+  'value',
+  'view',
+  'wait',
+]);
 const ALLOWED_PLAN_VALUES = new Set([
   'free',
   'static',
@@ -35,10 +87,21 @@ const ALLOWED_PLAN_VALUES = new Set([
   'db-basic',
   'db-premium',
   'db-enterprise',
+  'cache-free',
+  'cache-starter',
+  'cache-basic',
+  'cache-premium',
+  'cache-enterprise',
+  'queue-free',
+  'queue-starter',
+  'queue-basic',
+  'queue-premium',
+  'queue-enterprise',
 ]);
 const ALLOWED_PAYMENT_MODE_VALUES = new Set(['hourly', 'monthly', 'yearly']);
-const ALLOWED_TYPE_PROJECT_VALUES = new Set(['http', 'postgresql', 'mariadb']);
+const ALLOWED_TYPE_PROJECT_VALUES = new Set(['http', 'postgresql', 'mariadb', 'valkey']);
 const ALLOWED_RUNTIME_VALUES = new Set(['nodejs', 'python']);
+const ALLOWED_EXPOSURE_VALUES = new Set(['public', 'private']);
 const GITHUB_RUNTIME_VERSIONS = {
   nodejs: ['24', '22', '20'],
   python: ['3.13', '3.12', '3.11'],
@@ -67,7 +130,9 @@ const WIZARD_DATABASE_PLAN_OPTIONS = [
   'db-free',
 ];
 const WIZARD_PAYMENT_MODE_OPTIONS = ['hourly', 'monthly', 'yearly'];
-const WIZARD_TYPE_PROJECT_OPTIONS = ['http', 'postgresql', 'mariadb'];
+const WIZARD_TYPE_PROJECT_OPTIONS = ['http', 'postgresql', 'mariadb', 'valkey'];
+const WIZARD_VALKEY_PROFILE_OPTIONS = ['key_value', 'cache', 'queue'];
+const WIZARD_HTTP_EXPOSURE_OPTIONS = ['public', 'private'];
 let promptInterface;
 let pipedInputPromise;
 let pipedInputIndex = 0;
@@ -95,7 +160,7 @@ Usage:
   zenifra help <command>
   zenifra auth login [--profile <name>] [--api-base <url>] [--code <code>]
   zenifra auth api-key --key <znf_key> [--profile <name>] [--api-base <url>]
-  zenifra auth logout [--profile <name>]
+  zenifra auth logout [--profile <name>] [--revoke]
   zenifra profile list [--json]
   zenifra profile show [<name>] [--json]
   zenifra profile add [--name <name>] [--description <text>] [--api-base <url>] [--mode <api-key|login>] [--key <znf_key>] [--json]
@@ -104,20 +169,30 @@ Usage:
   zenifra profile remove <name> [--json]
   zenifra orgs [--json]
   zenifra org set [--org <id>]
-  zenifra plans [--type <all|http|database|storage>] [--json]
+  zenifra plans [--type <all|http|database|storage|valkey>] [--json]
   zenifra create project
   zenifra create project --name <name> --plan <plan> --payment-mode <mode> --config <json|@file> [--description <text>] [--org <id>] [--json]
-  zenifra projects [--json] [--org <id>] [--type <http|postgresql|mariadb>] [--page <n>] [--limit <n>]
+  zenifra projects [--json] [--org <id>] [--type <http|postgresql|mariadb|valkey>] [--page <n>] [--limit <n>]
+  zenifra valkey status --project <id> [--json]
+  zenifra valkey connection --project <id> [--json]
+  zenifra valkey credentials rotate --project <id> [--idempotency-key <key>] [--wait] [--interval <seconds>] [--timeout <seconds>] [--json]
+  zenifra valkey credentials status --project <id> --operation <id> [--json]
   zenifra project info --project <id> [--json]
   zenifra project url --project <id> [--json]
   zenifra project logs --project <id> [--instance <id>] [--json]
   zenifra project metrics --project <id> [--instance <id>] [--json]
   zenifra project network --project <id> [--view <summary|status-codes|routes|user-agents|request-events|source-ips>] [--json]
   zenifra project image set --project <id> --image <image> [--json]
+  zenifra project exposure set --project <id> --exposure <public|private> [--json]
   zenifra project envs --project <id> [--json] [--show-values]
   zenifra project env add --project <id> --name <name> --value <value> [--json]
   zenifra project env update --project <id> --name <name> --value <value> [--json]
   zenifra project env remove --project <id> --name <name> [--json]
+  zenifra project autoscaling --project <id> [--json]
+  zenifra project autoscaling set --project <id> --min <n> --max <n> [--cpu <percent>] [--memory <percent>] [--json]
+  zenifra project autoscaling disable --project <id> [--json]
+  zenifra project autoscaling events --project <id> [--direction <scale_up|scale_down>] [--from <iso>] [--to <iso>] [--page <n>] [--limit <n>] [--json]
+  zenifra project billing usage --project <id> [--from <iso>] [--to <iso>] [--page <n>] [--limit <n>] [--json]
   zenifra project instances --project <id> [--json]
   zenifra project instances set --project <id> --count <n> [--json]
   zenifra builds --project <id> [--page <n>] [--limit <n>] [--branch <name>] [--status <status>] [--json]
@@ -138,7 +213,7 @@ Run "zenifra help <command>" or "zenifra <command> --help" for command-specific
 const HELP_SPECS = [
   {
     command: 'auth',
-    usage: 'zenifra auth\n  zenifra auth login [--profile <name>] [--api-base <url>] [--code <code>]\n  zenifra auth api-key --key <znf_key> [--profile <name>] [--api-base <url>]\n  zenifra auth logout [--profile <name>]',
+    usage: 'zenifra auth\n  zenifra auth login [--profile <name>] [--api-base <url>] [--code <code>]\n  zenifra auth api-key --key <znf_key> [--profile <name>] [--api-base <url>]\n  zenifra auth logout [--profile <name>] [--revoke]',
     description: 'Gerencia a autenticacao dos perfis locais da CLI.',
     examples: ['zenifra auth', 'zenifra auth login --profile staging', 'zenifra auth api-key --profile prod --key znf_0123456789abcdef01234567_abcd...'],
     output: 'Zenifra CLI - auth',
@@ -168,11 +243,12 @@ const HELP_SPECS = [
   },
   {
     command: 'auth logout',
-    usage: 'zenifra auth logout [--profile <name>]',
+    usage: 'zenifra auth logout [--profile <name>] [--revoke]',
     description: 'Remove a autenticacao do perfil ativo ou do perfil informado.',
-    flags: ['--profile <name>  Limpa outro perfil sem trocar o perfil ativo.'],
-    examples: ['zenifra auth logout', 'zenifra auth logout --profile staging'],
+    flags: ['--profile <name>  Limpa outro perfil sem trocar o perfil ativo.', '--revoke          Revoga as sessoes de usuario no servidor antes de limpar o perfil.'],
+    examples: ['zenifra auth logout', 'zenifra auth logout --profile staging', 'zenifra auth logout --revoke'],
     output: 'Autenticacao removida do perfil active.',
+    notes: ['Sem --revoke, remove somente a credencial local. A revogacao invalida as sessoes de login do usuario e nao se aplica a API keys.'],
   },
   {
     command: 'profile',
@@ -263,16 +339,65 @@ const HELP_SPECS = [
   },
   {
     command: 'plans',
-    usage: 'zenifra plans [--type <all|http|database|storage>] [--json]',
-    description: 'Lista os catalogos publicos de preco de planos HTTP, banco e armazenamento.',
-    flags: ['--type <type>  Filtra o catalogo: all, http, database ou storage.', '--json         Imprime a resposta em JSON.'],
-    examples: ['zenifra plans', 'zenifra plans --type http', 'zenifra plans --type storage --json'],
+    usage: 'zenifra plans [--type <all|http|database|storage|valkey>] [--json]',
+    description: 'Lista os catalogos publicos de preco de planos HTTP, banco, armazenamento e Valkey.',
+    flags: ['--type <type>  Filtra o catalogo: all, http, database, storage, valkey, key-value, cache ou queue.', '--json         Imprime a resposta em JSON.'],
+    examples: ['zenifra plans', 'zenifra plans --type http', 'zenifra plans --type valkey --json'],
     output: 'HTTP\nPlano  Hora     Mes      Ano      Recursos\nfree   R$ 0,00  R$ 0,00  R$ 0,00  1 GB Armazenamento Efemero',
     jsonOutput: '{"http":[{"plan":"free","prices":{"hourly":0,"monthly":0,"yearly":0},"features":["1 GB Armazenamento Efemero"]}],"database":[],"storage":[]}',
   },
+  {
+    command: 'valkey',
+    usage: 'zenifra valkey\n  zenifra valkey status --project <id> [--json]\n  zenifra valkey connection --project <id> [--json]\n  zenifra valkey credentials rotate --project <id> [--idempotency-key <key>] [--wait] [--interval <seconds>] [--timeout <seconds>] [--json]\n  zenifra valkey credentials status --project <id> --operation <id> [--json]',
+    description: 'Consulta projetos Valkey e gerencia suas conexoes e credenciais.',
+    examples: ['zenifra valkey status --project proj_1', 'zenifra valkey connection --project proj_1', 'zenifra valkey credentials rotate --project proj_1 --wait'],
+    output: 'Zenifra CLI - valkey',
+    notes: ['A string de conexao completa aparece somente quando uma criacao ou rotacao a disponibiliza.'],
+  },
+  {
+    command: 'valkey status',
+    usage: 'zenifra valkey status --project <id> [--json]',
+    description: 'Mostra estado, perfil, versao e persistencia de um projeto Valkey.',
+    flags: ['--project <id>  ID do projeto.', '--json          Imprime a resposta em JSON.'],
+    examples: ['zenifra valkey status --project proj_1'],
+    output: 'Status     Perfil  Versao  Persistente  Instancias\nrunning    cache   9.1.1   nao           1',
+  },
+  {
+    command: 'valkey connection',
+    usage: 'zenifra valkey connection --project <id> [--json]',
+    description: 'Mostra os dados de conexao de um projeto Valkey sem revelar a credencial.',
+    flags: ['--project <id>  ID do projeto.', '--json          Imprime a resposta em JSON.'],
+    examples: ['zenifra valkey connection --project proj_1'],
+    output: 'Host                 Porta  TLS  Conexao\nvalkey.example.com   6380   sim  valkeys://default:********@valkey.example.com:6380/0',
+    notes: ['Use a credencial recebida na criacao ou em uma rotacao concluida.'],
+  },
+  {
+    command: 'valkey credentials',
+    usage: 'zenifra valkey credentials\n  zenifra valkey credentials rotate --project <id> [--idempotency-key <key>] [--wait] [--interval <seconds>] [--timeout <seconds>] [--json]\n  zenifra valkey credentials status --project <id> --operation <id> [--json]',
+    description: 'Agrupa comandos de renovacao e acompanhamento de credenciais Valkey.',
+    examples: ['zenifra valkey credentials rotate --project proj_1', 'zenifra valkey credentials status --project proj_1 --operation operation_1'],
+    output: 'Zenifra CLI - valkey credentials',
+  },
+  {
+    command: 'valkey credentials rotate',
+    usage: 'zenifra valkey credentials rotate --project <id> [--idempotency-key <key>] [--wait] [--interval <seconds>] [--timeout <seconds>] [--json]',
+    description: 'Solicita a renovacao da credencial e retorna uma operacao acompanhavel.',
+    flags: ['--project <id>          ID do projeto.', '--idempotency-key <key> Chave para repetir a mesma solicitacao.', '--wait                  Aguarda a conclusao.', '--interval <seconds>    Intervalo do polling. Padrao: 2.', '--timeout <seconds>     Timeout total. Padrao: 900.', '--json                  Imprime a resposta em JSON.'],
+    examples: ['zenifra valkey credentials rotate --project proj_1', 'zenifra valkey credentials rotate --project proj_1 --wait --timeout 120'],
+    output: 'Operacao aceita: rotation_123\nEstado: accepted',
+    notes: ['Salve a nova string de conexao quando a operacao atingir completed.'],
+  },
+  {
+    command: 'valkey credentials status',
+    usage: 'zenifra valkey credentials status --project <id> --operation <id> [--json]',
+    description: 'Consulta o estado de uma renovacao de credencial Valkey.',
+    flags: ['--project <id>     ID do projeto.', '--operation <id>   ID da operacao.', '--json             Imprime a resposta em JSON.'],
+    examples: ['zenifra valkey credentials status --project proj_1 --operation rotation_123'],
+    output: 'Operacao: rotation_123\nEstado: completed',
+  },
   {
     command: 'projects',
-    usage: 'zenifra projects [--json] [--org <id>] [--type <http|postgresql|mariadb>] [--page <n>] [--limit <n>]',
+    usage: 'zenifra projects [--json] [--org <id>] [--type <http|postgresql|mariadb|valkey>] [--page <n>] [--limit <n>]',
     description: 'Lista projetos da organizacao ativa ou da API key.',
     flags: ['--json       Imprime a resposta em JSON.', '--org <id>   Usa uma organizacao especifica com sessao de usuario.', '--type <type> Filtra por tipo de projeto.', '--page <n>   Pagina. Padrao: 1.', '--limit <n>  Itens por pagina. Padrao: 15.'],
     examples: ['zenifra projects --type http --page 1 --limit 15', 'zenifra projects --json'],
@@ -281,9 +406,9 @@ const HELP_SPECS = [
   },
   {
     command: 'create project',
-    usage: 'zenifra create project\n  zenifra create project --name <name> --plan <plan> --payment-mode <mode> --config <json|@file> [--description <text>] [--org <id>] [--json]',
+    usage: 'zenifra create project\n  zenifra create project --name <name> --plan <plan> --payment-mode <mode> --config <json|@file> [--description <text>] [--idempotency-key <key>] [--org <id>] [--json]',
     description: 'Cria um projeto via wizard interativo ou via payload de configuracao JSON.',
-    flags: ['--name <name>          Nome do projeto.', '--plan <plan>          Plano do projeto.', '--payment-mode <mode>  Modo de pagamento.', '--config <json|@file>  JSON inline ou arquivo.', '--description <text>   Descricao opcional.', '--json                 Imprime a resposta em JSON.'],
+    flags: ['--name <name>             Nome do projeto.', '--plan <plan>             Plano do projeto.', '--payment-mode <mode>     Modo de pagamento.', '--config <json|@file>     JSON inline ou arquivo.', '--description <text>      Descricao opcional.', '--idempotency-key <key>   Chave para repetir a mesma criacao com seguranca.', '--json                    Imprime a resposta em JSON.'],
     examples: ['zenifra create project', 'zenifra create project --name api-web --plan free --payment-mode hourly --config @examples/http-project.json'],
     output: 'Campo    Valor\n-------  --------------------------------------\nProjeto  507f1f77bcf86cd799439012\nDominio  https://api-web.client.zenifra.com',
     jsonOutput: '{"status":"success","data":{"id":"507f1f77bcf86cd799439012","name":"api-web"}}',
@@ -291,11 +416,11 @@ const HELP_SPECS = [
   },
   {
     command: 'project',
-    usage: 'zenifra project\n  zenifra project info --project <id> [--json]\n  zenifra project url --project <id> [--json]\n  zenifra project logs --project <id> [--instance <id>] [--json]\n  zenifra project metrics --project <id> [--instance <id>] [--json]\n  zenifra project network --project <id> [--view <summary|status-codes|routes|user-agents|request-events|source-ips>] [--json]\n  zenifra project image set --project <id> --image <image> [--json]\n  zenifra project envs --project <id> [--json] [--show-values]\n  zenifra project env add --project <id> --name <name> --value <value> [--json]\n  zenifra project env update --project <id> --name <name> --value <value> [--json]\n  zenifra project env remove --project <id> --name <name> [--json]\n  zenifra project instances --project <id> [--json]\n  zenifra project instances set --project <id> --count <n> [--json]',
+    usage: 'zenifra project\n  zenifra project info --project <id> [--json]\n  zenifra project url --project <id> [--json]\n  zenifra project logs --project <id> [--instance <id>] [--json]\n  zenifra project metrics --project <id> [--instance <id>] [--json]\n  zenifra project network --project <id> [--view <summary|status-codes|routes|user-agents|request-events|source-ips>] [--json]\n  zenifra project image set --project <id> --image <image> [--json]\n  zenifra project exposure set --project <id> --exposure <public|private> [--json]\n  zenifra project envs --project <id> [--json] [--show-values]\n  zenifra project env add --project <id> --name <name> --value <value> [--json]\n  zenifra project env update --project <id> --name <name> --value <value> [--json]\n  zenifra project env remove --project <id> --name <name> [--json]\n  zenifra project autoscaling --project <id> [--json]\n  zenifra project autoscaling set --project <id> --min <n> --max <n> [--cpu <percent>] [--memory <percent>] [--json]\n  zenifra project autoscaling disable --project <id> [--json]\n  zenifra project autoscaling events --project <id> [--direction <scale_up|scale_down>] [--from <iso>] [--to <iso>] [--page <n>] [--limit <n>] [--json]\n  zenifra project billing usage --project <id> [--from <iso>] [--to <iso>] [--page <n>] [--limit <n>] [--json]\n  zenifra project instances --project <id> [--json]\n  zenifra project instances set --project <id> --count <n> [--json]',
     description: 'Agrupa comandos operacionais e de introspecao sobre um projeto especifico.',
     examples: ['zenifra project', 'zenifra project info --project proj_1', 'zenifra project env add --project proj_1 --name NODE_ENV --value production'],
     output: 'Zenifra CLI - project',
-    notes: ['Use "zenifra help project <subcomando>" para detalhes de info, url, logs, metrics, network, image, envs e instances.'],
+    notes: ['Use "zenifra help project <subcomando>" para detalhes de info, url, logs, metrics, network, image, exposure, autoscaling, billing, envs e instances.'],
   },
   {
     command: 'project info',
@@ -352,6 +477,16 @@ const HELP_SPECS = [
     output: 'Imagem atualizada com sucesso.',
     jsonOutput: '{"status":"success","message":"updated with success"}',
   },
+  {
+    command: 'project exposure set',
+    usage: 'zenifra project exposure set --project <id> --exposure <public|private> [--json]',
+    description: 'Altera se um projeto HTTP expoe rota publica e dominio.',
+    flags: ['--project <id>    ID do projeto.', '--exposure <mode> Use public para criar rota publica ou private para remover exposicao.', '--json            Imprime a resposta em JSON.'],
+    examples: ['zenifra project exposure set --project 507f1f77bcf86cd799439012 --exposure private', 'zenifra project exposure set --project 507f1f77bcf86cd799439012 --exposure public --json'],
+    output: 'Campo      Valor\n---------  ----------------------------------\nExposicao  private\nDominio    -',
+    jsonOutput: '{"status":"success","message":"project exposure updated with success","exposure":"private","custom_domains":[]}',
+    notes: ['Ao mudar para private, a API remove a rota publica e dominios personalizados do projeto.'],
+  },
   {
     command: 'project envs',
     usage: 'zenifra project envs --project <id> [--json] [--show-values]',
@@ -392,10 +527,55 @@ const HELP_SPECS = [
     jsonOutput: '{"status":"success","message":"updated with success","envs":[]}',
     notes: ['Falha se a variavel nao existir.'],
   },
+  {
+    command: 'project autoscaling',
+    usage: 'zenifra project autoscaling --project <id> [--json]',
+    description: 'Mostra a configuracao de auto-scaling HTTP do projeto.',
+    flags: ['--project <id>  ID do projeto.', '--json          Imprime a resposta em JSON.'],
+    examples: ['zenifra project autoscaling --project 507f1f77bcf86cd799439012'],
+    output: 'Campo       Valor\n----------  -----\nStatus      ativo\nMinimo      2\nMaximo      8\nCPU alvo    70%\nMemoria     80%',
+    jsonOutput: '{"enabled":true,"min_instances":2,"max_instances":8,"target_cpu_utilization_percent":70,"target_memory_utilization_percent":80}',
+  },
+  {
+    command: 'project autoscaling set',
+    usage: 'zenifra project autoscaling set --project <id> --min <n> --max <n> [--cpu <percent>] [--memory <percent>] [--json]',
+    description: 'Ativa ou atualiza o auto-scaling HTTP do projeto.',
+    flags: ['--project <id>    ID do projeto.', '--min <n>        Minimo de instancias reservadas.', '--max <n>        Maximo de instancias permitidas.', '--cpu <percent>  CPU alvo. Padrao da API: 70.', '--memory <percent> Memoria alvo. Padrao da API: 80.', '--json           Imprime a resposta em JSON.'],
+    examples: ['zenifra project autoscaling set --project 507f1f77bcf86cd799439012 --min 2 --max 8 --cpu 70 --memory 80'],
+    output: 'Auto-scaling atualizado: 2-8 instancias.',
+    jsonOutput: '{"status":"success","message":"project autoscaling updated with success","data":{"autoscaling":{"enabled":true,"min_instances":2,"max_instances":8}}}',
+  },
+  {
+    command: 'project autoscaling disable',
+    usage: 'zenifra project autoscaling disable --project <id> [--json]',
+    description: 'Desativa o auto-scaling HTTP e volta para instancias fixas no minimo configurado.',
+    flags: ['--project <id>  ID do projeto.', '--json          Imprime a resposta em JSON.'],
+    examples: ['zenifra project autoscaling disable --project 507f1f77bcf86cd799439012'],
+    output: 'Auto-scaling desativado.',
+    jsonOutput: '{"status":"success","message":"project autoscaling updated with success","data":{"autoscaling":{"enabled":false}}}',
+  },
+  {
+    command: 'project autoscaling events',
+    usage: 'zenifra project autoscaling events --project <id> [--direction <scale_up|scale_down>] [--from <iso>] [--to <iso>] [--page <n>] [--limit <n>] [--json]',
+    description: 'Lista o historico de scale up e scale down do auto-scaling HTTP.',
+    flags: ['--project <id>       ID do projeto.', '--direction <valor> Filtra por scale_up ou scale_down.', '--from <iso>         Inicio do periodo.', '--to <iso>           Fim do periodo.', '--page <n>           Pagina. Padrao da API: 1.', '--limit <n>          Itens por pagina. Maximo da API: 100.', '--json               Imprime a resposta em JSON.'],
+    examples: ['zenifra project autoscaling events --project 507f1f77bcf86cd799439012 --direction scale_up'],
+    output: 'Quando                    Direcao   Instancias  Limites          Motivo\n05/06/2026, 18:40        aumento   2 -> 5     CPU 91%/70%    capacidade aumentada',
+    jsonOutput: '{"events":[{"direction":"scale_up","previous_instances":2,"new_instances":5,"occurred_at":"2026-06-05T21:40:00.000Z"}],"pagination":{"page":1,"limit":10,"total":1,"total_pages":1}}',
+  },
+  {
+    command: 'project billing usage',
+    usage: 'zenifra project billing usage --project <id> [--from <iso>] [--to <iso>] [--page <n>] [--limit <n>] [--json]',
+    description: 'Lista o consumo horario consolidado de um projeto.',
+    flags: ['--project <id>  ID do projeto.', '--from <iso>    Inicio do periodo.', '--to <iso>      Fim do periodo.', '--page <n>      Pagina. Padrao da API: 1.', '--limit <n>     Itens por pagina. Maximo: 50.', '--json          Imprime a resposta em JSON.'],
+    examples: ['zenifra project billing usage --project 507f1f77bcf86cd799439012 --from 2026-06-01T00:00:00Z --limit 20'],
+    output: 'Inicio                    Fim                       Instancia-horas  Armazenamento  Total\n2026-06-01T10:00:00.000Z  2026-06-01T11:00:00.000Z  2                1.5 GB-h         R$ 0,30',
+    jsonOutput: '{"hours":[],"summary":{"currency":"brl","compute_amount":0,"storage_amount":0,"total_amount":0},"pagination":{"page":1,"limit":10,"total":0,"total_pages":0}}',
+  },
   {
     command: 'project instances',
     usage: 'zenifra project instances --project <id> [--json]',
-    description: 'Lista instancias/pods do projeto.',
+    description: 'Lista instancias do projeto.',
     flags: ['--project <id>  ID do projeto.', '--json          Imprime a resposta em JSON.'],
     examples: ['zenifra project instances --project 507f1f77bcf86cd799439012'],
     output: 'Instancia\nweb-1',
@@ -426,11 +606,11 @@ const HELP_SPECS = [
     flags: [
       '--project <id>        ID do projeto.',
       '--build <id>          ID do build.',
-      '--cursor <n>          Cursor inicial. Padrao: 0.',
-      '--limit <n>           Quantidade de logs por request. Padrao: 200.',
+      '--cursor <n>          Cursor inicial inteiro, maior ou igual a 0. Padrao: 0.',
+      '--limit <n>           Quantidade de logs por request, entre 1 e 500. Padrao: 200.',
       '--follow              Continua em polling ate o build finalizar.',
-      '--interval <seconds>  Intervalo de polling com --follow. Padrao: 5.',
-      '--timeout <seconds>   Timeout total com --follow. Padrao: 900.',
+      '--interval <seconds>  Intervalo de polling com --follow, minimo 0.1. Padrao: 5.',
+      '--timeout <seconds>   Timeout total com --follow, minimo 1. Padrao: 900.',
       '--json                Imprime a resposta em JSON.',
     ],
     examples: ['zenifra builds logs --project 507f1f77bcf86cd799439012 --build build_123', 'zenifra builds logs --project 507f1f77bcf86cd799439012 --build build_123 --follow'],
@@ -466,7 +646,7 @@ const HELP_SPECS = [
     command: 'deploy watch',
     usage: 'zenifra deploy watch --project <id> --build <id> [--interval <seconds>] [--timeout <seconds>] [--json]',
     description: 'Acompanha um build em tempo real, fazendo polling do status e imprimindo os logs incrementais do build ate o estado terminal.',
-    flags: ['--project <id>        ID do projeto.', '--build <id>          ID do build.', '--interval <seconds>  Intervalo de polling. Padrao: 5.', '--timeout <seconds>   Timeout total. Padrao: 900.', '--json                Imprime cada resposta em JSON.'],
+    flags: ['--project <id>        ID do projeto.', '--build <id>          ID do build.', '--interval <seconds>  Intervalo de polling, minimo 0.1. Padrao: 5.', '--timeout <seconds>   Timeout total, minimo 1. Padrao: 900.', '--json                Imprime cada resposta em JSON.'],
     examples: [
       'zenifra deploy watch --project 507f1f77bcf86cd799439012 --build build_123',
       'zenifra deploy watch --project 507f1f77bcf86cd799439012 --build build_123 --interval 2',
@@ -543,7 +723,7 @@ function removedProjectsCreateMessage() {
 }
 
 function isNamespaceCommand(command) {
-  return ['auth', 'profile', 'project', 'org'].includes(command);
+  return ['auth', 'profile', 'project', 'org', 'valkey'].includes(command);
 }
 
 function parseArgs(argv) {
@@ -578,6 +758,17 @@ function parseArgs(argv) {
   return { positional, flags };
 }
 
+function flagNameForDisplay(value) {
+  return `--${String(value).replace(/[A-Z]/g, (character) => `-${character.toLowerCase()}`)}`;
+}
+
+function validateKnownFlags(flags) {
+  const unknown = Object.keys(flags).filter((name) => !KNOWN_FLAG_NAMES.has(name));
+  if (unknown.length > 0) {
+    throw new CliError(`Flag desconhecida: ${unknown.map(flagNameForDisplay).join(', ')}.`);
+  }
+}
+
 function emptyProfileStore() {
   return {
     version: PROFILE_STORE_VERSION,
@@ -667,7 +858,9 @@ async function migrateLegacySession() {
   });
   store.profiles[DEFAULT_PROFILE_NAME] = migratedProfile;
   store.activeProfile = DEFAULT_PROFILE_NAME;
-  return writeProfileStore(store);
+  const normalized = await writeProfileStore(store);
+  await rm(SESSION_FILE, { force: true });
+  return normalized;
 }
 
 async function readProfileStore() {
@@ -861,9 +1054,16 @@ function estimateWizardTotal(state = {}) {
       if (state.httpStoragePersistent) total += 1;
     }
 
+    if (state.planAllowsAutoscaling) {
+      total += 1;
+      if (state.httpAutoscalingEnabled) total += 3;
+    }
+
     total += 1;
     if (state.envs?.enabled) total += state.envs.count * 3;
 
+    total += 1;
+
     if (state.httpSource === 'github') {
       total += 9;
     } else if (state.httpSource === 'oci') {
@@ -877,13 +1077,13 @@ function estimateWizardTotal(state = {}) {
       total += 1;
     }
 
-    if (state.planAllowsBlockIp) {
+    if (state.httpExposure !== 'private' && state.planAllowsBlockIp) {
       total += 2;
       if (state.whitelist?.enabled) total += state.whitelist.count * 3;
       if (state.blacklist?.enabled) total += state.blacklist.count * 3;
     }
 
-    if (state.planAllowsSubdomain) total += 1;
+    if (state.httpExposure !== 'private' && state.planAllowsSubdomain) total += 1;
     return total;
   }
 
@@ -898,6 +1098,11 @@ function estimateWizardTotal(state = {}) {
     return total;
   }
 
+  if (typeProject === 'valkey') {
+    total += 3;
+    return total;
+  }
+
   return 18;
 }
 
@@ -1199,8 +1404,25 @@ async function promptHidden(question) {
   });
 }
 
-async function request(session, flags, method, path, { body, orgId, tokenRequired = true } = {}) {
-  const credential = resolveCredential(session);
+function httpTimeoutMs() {
+  const configured = process.env.ZENIFRA_HTTP_TIMEOUT_MS;
+  if (configured === undefined) return DEFAULT_HTTP_TIMEOUT_MS;
+
+  const value = Number(configured);
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new CliError('ZENIFRA_HTTP_TIMEOUT_MS deve ser um inteiro positivo em milissegundos.');
+  }
+  return value;
+}
+
+async function request(session, flags, method, path, {
+  body,
+  orgId,
+  tokenRequired = true,
+  credential: credentialOverride,
+  headers: extraHeaders = {},
+} = {}) {
+  const credential = credentialOverride || resolveCredential(session);
   if (tokenRequired && !credential) {
     throw new CliError('Voce precisa autenticar primeiro: zenifra auth login, zenifra auth api-key --key <znf_key> ou ZENIFRA_API_KEY.');
   }
@@ -1209,6 +1431,14 @@ async function request(session, flags, method, path, { body, orgId, tokenRequire
   if (body !== undefined) {
     headers['Content-Type'] = 'application/json';
   }
+  for (const [name, value] of Object.entries(extraHeaders)) {
+    if (value === undefined) continue;
+    const normalizedName = name.toLowerCase();
+    if (['authorization', 'x-organization-id', 'content-type'].includes(normalizedName)) {
+      throw new CliError(`Header nao permitido: ${name}.`);
+    }
+    headers[name] = String(value);
+  }
   if (credential?.token) {
     headers.Authorization = `Bearer ${credential.token}`;
   }
@@ -1216,11 +1446,21 @@ async function request(session, flags, method, path, { body, orgId, tokenRequire
     headers['x-organization-id'] = orgId;
   }
 
-  const response = await fetch(`${apiBaseUrl(session, flags)}${path}`, {
-    method,
-    headers,
-    body: body === undefined ? undefined : JSON.stringify(body),
-  });
+  const timeoutMs = httpTimeoutMs();
+  let response;
+  try {
+    response = await fetch(`${apiBaseUrl(session, flags)}${path}`, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch (error) {
+    if (error?.name === 'TimeoutError' || error?.name === 'AbortError') {
+      throw new CliError(`A API da Zenifra nao respondeu em ate ${timeoutMs} ms.`);
+    }
+    throw new CliError(`Nao foi possivel conectar a API da Zenifra: ${error?.message || 'erro de rede'}.`);
+  }
 
   const text = await response.text();
   let payload = {};
@@ -1234,12 +1474,18 @@ async function request(session, flags, method, path, { body, orgId, tokenRequire
 
   if (!response.ok) {
     const message = payload?.message || payload?.error || `Zenifra API retornou HTTP ${response.status}`;
-    if (response.status === 401 || response.status === 403) {
+    if (response.status === 401) {
       if (credential?.type === 'api_key') {
-        throw new CliError(`${message}. Verifique se a API key esta ativa, possui permissao RBAC e se o IP atual esta permitido.`);
+        throw new CliError(`${message}. Verifique se a API key esta ativa e se o IP atual esta permitido.`);
       }
       throw new CliError(`${message}. Rode "zenifra auth login" para renovar sua sessao.`);
     }
+    if (response.status === 403) {
+      throw new CliError(message);
+    }
+    if (response.status === 429 && Number.isFinite(Number(payload?.retry_after_seconds))) {
+      throw new CliError(`${message} Tente novamente em ${Number(payload.retry_after_seconds)} segundo(s).`);
+    }
     if (String(message).includes('missing x-organization-id')) {
       throw new CliError('Organizacao nao selecionada. Rode "zenifra org set" ou use --org <id>.');
     }
@@ -1345,19 +1591,33 @@ function printEnvs(envs, flags) {
 }
 
 function printProject(project) {
-  const url = projectUrlOf(project);
+  const managedService = project.managed_service;
+  const isValkey = project.type_project === 'valkey' || managedService?.engine === 'valkey';
   const rows = [
     { label: 'ID', value: projectIdOf(project) || '-' },
     { label: 'Nome', value: project.name || '-' },
     { label: 'Status', value: project.status || '-' },
     { label: 'Tipo', value: project.type_project || '-' },
     { label: 'Plano', value: project.plan || '-' },
-    { label: 'URL', value: url || '-' },
-    { label: 'Imagem', value: project.image || '-' },
-    { label: 'Instancias', value: project.instances ?? '-' },
-    { label: 'Instancias atuais', value: project.additional_info?.current_instances ?? '-' },
   ];
 
+  if (isValkey) {
+    rows.push(
+      { label: 'Perfil', value: managedService?.profile || '-' },
+      { label: 'Versao', value: managedService?.version || '-' },
+      { label: 'Persistente', value: managedService?.topology?.persistent === true ? 'sim' : 'nao' },
+      { label: 'Instancias', value: project.instances ?? '-' },
+    );
+  } else {
+    rows.push(
+      { label: 'Exposicao', value: project.exposure || '-' },
+      { label: 'URL', value: projectUrlOf(project) || '-' },
+      { label: 'Imagem', value: project.image || '-' },
+      { label: 'Instancias', value: project.instances ?? '-' },
+      { label: 'Instancias atuais', value: project.additional_info?.current_instances ?? '-' },
+    );
+  }
+
   for (const row of rows) {
     process.stdout.write(`${row.label}: ${row.value}\n`);
   }
@@ -1507,6 +1767,18 @@ async function handleLogout(session, flags) {
     throw new CliError('Nenhum perfil ativo configurado. Crie um perfil com "zenifra profile add" ou autentique com "zenifra auth login".');
   }
   const target = requireExistingProfile(session, targetName);
+  if (flags.revoke) {
+    if (!target.accessToken) {
+      throw new CliError('A revogacao exige um perfil autenticado por login de usuario; API keys devem ser revogadas na organizacao.');
+    }
+    await request(target, flags, 'DELETE', '/authentication', {
+      credential: {
+        token: target.accessToken,
+        type: 'user',
+        source: 'profile',
+      },
+    });
+  }
   target.accessToken = undefined;
   target.apiKey = undefined;
   target.selectedOrganizationId = undefined;
@@ -1516,7 +1788,7 @@ async function handleLogout(session, flags) {
   if (target.__profileName === getProfileName(session)) {
     Object.assign(session, buildSession(target.__store));
   }
-  process.stdout.write(`Autenticacao removida do perfil ${target.__profileName}.\n`);
+  process.stdout.write(`Autenticacao removida do perfil ${target.__profileName}${flags.revoke ? ' e sessoes de usuario revogadas' : ''}.\n`);
 }
 
 function maskApiKey(value) {
@@ -1761,6 +2033,26 @@ function normalizePlan(value) {
     ['dbpremium', 'db-premium'],
     ['db_enterprise', 'db-enterprise'],
     ['dbenterprise', 'db-enterprise'],
+    ['cache_free', 'cache-free'],
+    ['cachefree', 'cache-free'],
+    ['cache_starter', 'cache-starter'],
+    ['cachestarter', 'cache-starter'],
+    ['cache_basic', 'cache-basic'],
+    ['cachebasic', 'cache-basic'],
+    ['cache_premium', 'cache-premium'],
+    ['cachepremium', 'cache-premium'],
+    ['cache_enterprise', 'cache-enterprise'],
+    ['cacheenterprise', 'cache-enterprise'],
+    ['queue_free', 'queue-free'],
+    ['queuefree', 'queue-free'],
+    ['queue_starter', 'queue-starter'],
+    ['queuestarter', 'queue-starter'],
+    ['queue_basic', 'queue-basic'],
+    ['queuebasic', 'queue-basic'],
+    ['queue_premium', 'queue-premium'],
+    ['queuepremium', 'queue-premium'],
+    ['queue_enterprise', 'queue-enterprise'],
+    ['queueenterprise', 'queue-enterprise'],
   ]);
 
   if (aliases.has(normalized)) return aliases.get(normalized);
@@ -1797,6 +2089,37 @@ function normalizeTypeProject(value) {
     ['postgresql', 'postgresql'],
     ['mariadb', 'mariadb'],
     ['maria db', 'mariadb'],
+    ['valkey', 'valkey'],
+    ['key value', 'valkey'],
+    ['key-value', 'valkey'],
+  ]);
+  return aliases.get(raw) || raw;
+}
+
+function normalizeValkeyProfile(value) {
+  const raw = normalizeFreeText(value);
+  const aliases = new Map([
+    ['key_value', 'key_value'],
+    ['key value', 'key_value'],
+    ['key-value', 'key_value'],
+    ['cache', 'cache'],
+    ['queue', 'queue'],
+  ]);
+  return aliases.get(raw) || raw;
+}
+
+function normalizeExposure(value) {
+  const raw = normalizeFreeText(value);
+  const aliases = new Map([
+    ['public', 'public'],
+    ['publico', 'public'],
+    ['público', 'public'],
+    ['exposto', 'public'],
+    ['sim', 'public'],
+    ['private', 'private'],
+    ['privado', 'private'],
+    ['nao', 'private'],
+    ['não', 'private'],
   ]);
   return aliases.get(raw) || raw;
 }
@@ -1842,6 +2165,13 @@ function isIpAccessEnabled(planCatalog, planId) {
   return planHasFeature(planCatalog, planId, 'Bloqueio de IPs');
 }
 
+function isAutoscalingEnabledForPlan(planCatalog, planId) {
+  const plan = Array.isArray(planCatalog)
+    ? planCatalog.find((item) => item?.plan === planId)
+    : undefined;
+  return plan?.permissions?.allow_autoscaling === 'true';
+}
+
 function getMaxReplicasFromFeatures(features) {
   const replicaFeature = features.find((feature) => /réplicas?/i.test(String(feature)));
   if (!replicaFeature) return 5;
@@ -1876,7 +2206,6 @@ async function fetchWizardCatalogs(session, flags) {
     unwrapData(await request(session, flags, 'GET', '/project/database/plans')),
     'os planos de banco',
   );
-
   return { httpPlans, availableInstances, databasePlans };
 }
 
@@ -1885,6 +2214,10 @@ function normalizePlansCatalogType(value) {
   if (!normalized || normalized === 'all') return 'all';
   if (normalized === 'http') return 'http';
   if (['database', 'db', 'postgresql', 'mariadb'].includes(normalized)) return 'database';
+  if (normalized === 'valkey') return 'valkey';
+  if (normalized === 'key-value' || normalized === 'key value' || normalized === 'key_value') return 'valkey-key_value';
+  if (normalized === 'cache') return 'valkey-cache';
+  if (normalized === 'queue') return 'valkey-queue';
   if (normalized === 'storage') return 'storage';
   return null;
 }
@@ -1917,6 +2250,49 @@ function humanizeStorageName(value) {
   return { storage: raw, type: '-' };
 }
 
+const VALKEY_PROFILE_LABELS = {
+  key_value: 'Key Value',
+  cache: 'Cache',
+  queue: 'Queue',
+};
+
+function requireValkeyCatalog(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || value.engine !== 'valkey'
+    || typeof value.version !== 'string'
+    || typeof value.currency !== 'string'
+    || !Array.isArray(value.profiles)
+    || !Array.isArray(value.plans)
+    || value.profiles.length === 0
+    || value.plans.length === 0) {
+    throw new CliError('Falha ao carregar o catalogo Valkey. Tente novamente mais tarde.');
+  }
+
+  const validProfiles = new Set(Object.keys(VALKEY_PROFILE_LABELS));
+  if (value.profiles.some((profile) => !validProfiles.has(profile?.id) || typeof profile.persistence !== 'boolean')) {
+    throw new CliError('Falha ao carregar o catalogo Valkey. Tente novamente mais tarde.');
+  }
+  if (value.plans.some((plan) => !validProfiles.has(plan?.profile) || typeof plan.id !== 'string' || !plan.prices || typeof plan.prices !== 'object')) {
+    throw new CliError('Falha ao carregar o catalogo Valkey. Tente novamente mais tarde.');
+  }
+
+  return value;
+}
+
+function valkeyProfileFilter(type) {
+  if (!type.startsWith('valkey-')) return null;
+  return type.slice('valkey-'.length);
+}
+
+function filterValkeyCatalog(catalog, profile) {
+  if (!profile) return catalog;
+  return {
+    ...catalog,
+    profiles: catalog.profiles.filter((entry) => entry.id === profile),
+    plans: catalog.plans.filter((plan) => plan.profile === profile),
+  };
+}
+
 async function fetchPlansCatalogs(session, flags, type) {
   if (type === 'http') {
     return {
@@ -1951,19 +2327,51 @@ async function fetchPlansCatalogs(session, flags, type) {
     };
   }
 
-  const [httpPayload, databasePayload, storagePayload] = await Promise.all([
+  if (type === 'valkey' || type.startsWith('valkey-')) {
+    const catalog = requireValkeyCatalog(
+      unwrapData(await request(session, flags, 'GET', '/managed-services/catalog', { tokenRequired: false })),
+    );
+    return {
+      http: [],
+      database: [],
+      storage: [],
+      valkey: filterValkeyCatalog(catalog, valkeyProfileFilter(type)),
+    };
+  }
+
+  const [httpPayload, databasePayload, storagePayload, valkeyPayload] = await Promise.all([
     request(session, flags, 'GET', '/project/plans', { tokenRequired: false }),
     request(session, flags, 'GET', '/project/database/plans', { tokenRequired: false }),
     request(session, flags, 'GET', '/project/storage/plans', { tokenRequired: false }),
+    request(session, flags, 'GET', '/managed-services/catalog', { tokenRequired: false }),
   ]);
 
   return {
     http: requireWizardCatalogArray(unwrapData(httpPayload), 'os planos HTTP'),
     database: requireWizardCatalogArray(unwrapData(databasePayload), 'os planos de banco'),
     storage: requireWizardCatalogArray(unwrapData(storagePayload), 'os planos de storage'),
+    valkey: requireValkeyCatalog(unwrapData(valkeyPayload)),
   };
 }
 
+function printValkeyCatalog(catalog, profileFilter) {
+  const profiles = profileFilter ? [profileFilter] : Object.keys(VALKEY_PROFILE_LABELS);
+  profiles.forEach((profile, index) => {
+    if (index > 0) process.stdout.write('\n');
+    process.stdout.write(`${VALKEY_PROFILE_LABELS[profile]}\n`);
+    const plans = catalog.plans.filter((plan) => plan.profile === profile);
+    printTable(plans, [
+      { label: 'Plano', value: (plan) => plan.id || '-' },
+      { label: 'Hora', value: (plan) => formatBrl(plan.prices?.hourly, catalog.currency) },
+      { label: 'Mes', value: (plan) => formatBrl(plan.prices?.monthly, catalog.currency) },
+      { label: 'Ano', value: (plan) => formatBrl(plan.prices?.yearly, catalog.currency) },
+      { label: 'Capacidade', value: (plan) => `${plan.resources?.cpu || '-'} / ${plan.resources?.memory || '-'}` },
+      { label: 'Storage incluído', value: (plan) => `${plan.included_storage_gb ?? 0} GB` },
+      { label: 'Alta disponibilidade', value: (plan) => plan.high_availability?.[profile] ? 'sim' : 'nao' },
+    ]);
+  });
+}
+
 function printPlansCatalogs(payload, type) {
   if (type === 'all' || type === 'http') {
     process.stdout.write('HTTP\n');
@@ -1999,12 +2407,17 @@ function printPlansCatalogs(payload, type) {
       { label: 'Ano', value: (storage) => formatBrl(storage.prices?.yearly) },
     ]);
   }
+
+  if (type === 'all' || type === 'valkey' || type.startsWith('valkey-')) {
+    if (type === 'all') process.stdout.write('\n');
+    printValkeyCatalog(payload.valkey, valkeyProfileFilter(type));
+  }
 }
 
 async function handlePlans(session, flags) {
   const type = normalizePlansCatalogType(flags.type);
   if (!type) {
-    throw new CliError('Tipo de catalogo invalido. Valores aceitos: all, http, database, storage.');
+    throw new CliError('Tipo de catalogo invalido. Valores aceitos: all, http, database, storage, valkey.');
   }
 
   const payload = await fetchPlansCatalogs(session, flags, type);
@@ -2016,9 +2429,99 @@ function formatAllowedValues(values) {
   return [...values].join(', ');
 }
 
-function validateCreateInput({ plan, paymentMode, config }) {
+function validateCreateAutoscaling(config, plan, typeProject) {
+  if (config?.autoscaling === undefined) return config;
+  if (typeProject !== 'http') {
+    throw new CliError('config.autoscaling deve ser informado apenas para projetos HTTP.');
+  }
+  if (plan === 'free') {
+    throw new CliError('Auto-scaling nao esta disponivel para projetos HTTP no plano free.');
+  }
+
+  const autoscaling = config.autoscaling;
+  if (!autoscaling || typeof autoscaling !== 'object' || Array.isArray(autoscaling)) {
+    throw new CliError('config.autoscaling deve ser um objeto.');
+  }
+  if (autoscaling.enabled !== true) {
+    throw new CliError('config.autoscaling.enabled deve ser true na criacao do projeto.');
+  }
+  if (autoscaling.min_instances !== undefined) {
+    throw new CliError('Use config.instances como minimo inicial; config.autoscaling.min_instances nao e aceito na criacao.');
+  }
+
+  const instances = Number(config.instances);
+  if (!Number.isInteger(instances) || instances <= 0) {
+    throw new CliError('config.instances deve ser um inteiro positivo ao criar um projeto com auto-scaling.');
+  }
+
+  const maxInstances = Number(autoscaling.max_instances);
+  if (!Number.isInteger(maxInstances) || maxInstances < instances) {
+    throw new CliError('config.autoscaling.max_instances deve ser um inteiro maior ou igual a config.instances.');
+  }
+
+  const nextAutoscaling = {
+    enabled: true,
+    max_instances: maxInstances,
+  };
+  for (const key of ['target_cpu_utilization_percent', 'target_memory_utilization_percent']) {
+    if (autoscaling[key] === undefined) continue;
+    const value = Number(autoscaling[key]);
+    if (!Number.isInteger(value) || value < 1 || value > 100) {
+      throw new CliError(`config.autoscaling.${key} deve ser um inteiro entre 1 e 100.`);
+    }
+    nextAutoscaling[key] = value;
+  }
+
+  return { ...config, autoscaling: nextAutoscaling };
+}
+
+function validateValkeyConfig(config, plan, catalog) {
+  const valkeyCatalog = requireValkeyCatalog(catalog);
+  const profile = normalizeValkeyProfile(config?.profile);
+  const profileDefinition = valkeyCatalog.profiles.find((entry) => entry.id === profile);
+  if (!profileDefinition) {
+    throw new CliError('config.profile invalido. Use key_value, cache ou queue.');
+  }
+
+  const planDefinition = valkeyCatalog.plans.find((entry) => entry.id === plan && entry.profile === profile);
+  if (!planDefinition) {
+    throw new CliError(`Plano ${plan} nao pode ser usado com o perfil ${profile}. Consulte "zenifra plans --type valkey".`);
+  }
+
+  if (config.version !== valkeyCatalog.version) {
+    throw new CliError(`config.version invalida: use ${valkeyCatalog.version}, conforme o catalogo Valkey.`);
+  }
+
+  const forbiddenFields = ['instances', 'envs', 'image', 'github', 'port', 'exposure', 'autoscaling'];
+  const forbiddenField = forbiddenFields.find((field) => config[field] !== undefined);
+  if (forbiddenField) {
+    throw new CliError(`Valkey nao aceita config.${forbiddenField}. A capacidade e definida pelo plano.`);
+  }
+
+  if (profileDefinition.persistence) {
+    if (!isRecord(config.storage) || config.storage.persistent !== true) {
+      throw new CliError('Perfis Valkey persistentes exigem storage.persistent=true.');
+    }
+    const capacity = Number(config.storage.capacity);
+    if (!Number.isInteger(capacity) || capacity < 1 || capacity > 250) {
+      throw new CliError('storage.capacity deve ser um inteiro entre 1 e 250 GiB.');
+    }
+  } else if (config.storage !== undefined) {
+    throw new CliError('O perfil Cache nao aceita storage.');
+  }
+
+  return {
+    ...config,
+    type_project: 'valkey',
+    profile,
+    version: valkeyCatalog.version,
+  };
+}
+
+function validateCreateInput({ plan, paymentMode, config, valkeyCatalog }) {
+  const nextTypeProject = normalizeTypeProject(config?.type_project);
   const nextPlan = normalizePlan(plan);
-  if (!nextPlan || !ALLOWED_PLAN_VALUES.has(nextPlan)) {
+  if (!nextPlan || (nextTypeProject !== 'valkey' && !ALLOWED_PLAN_VALUES.has(nextPlan))) {
     throw new CliError(`Plano invalido: "${plan}". Valores aceitos: ${formatAllowedValues(ALLOWED_PLAN_VALUES)}. Docs: ${DOCS_CREATE_HTTP_URL}`);
   }
 
@@ -2027,12 +2530,19 @@ function validateCreateInput({ plan, paymentMode, config }) {
     throw new CliError(`Modo de pagamento invalido: "${paymentMode}". Valores aceitos: ${formatAllowedValues(ALLOWED_PAYMENT_MODE_VALUES)}. Docs: ${DOCS_PAYMENTS_URL}`);
   }
 
-  const nextTypeProject = normalizeTypeProject(config?.type_project);
   if (!nextTypeProject || !ALLOWED_TYPE_PROJECT_VALUES.has(nextTypeProject)) {
     throw new CliError(`type_project invalido: "${config?.type_project}". Valores aceitos: ${formatAllowedValues(ALLOWED_TYPE_PROJECT_VALUES)}. Docs: ${DOCS_CREATE_HTTP_URL}`);
   }
 
   const nextConfig = { ...config, type_project: nextTypeProject };
+  if (nextTypeProject === 'valkey') {
+    return {
+      plan: nextPlan,
+      paymentMode: nextPaymentMode,
+      config: validateValkeyConfig(nextConfig, nextPlan, valkeyCatalog),
+    };
+  }
+
   if (nextTypeProject === 'http' && nextConfig.github) {
     const nextRuntime = normalizeRuntime(nextConfig.github.runtime);
     if (!nextRuntime || !ALLOWED_RUNTIME_VALUES.has(nextRuntime)) {
@@ -2041,10 +2551,22 @@ function validateCreateInput({ plan, paymentMode, config }) {
     nextConfig.github = { ...nextConfig.github, runtime: nextRuntime };
   }
 
+  if (nextTypeProject === 'http') {
+    const nextExposure = normalizeExposure(nextConfig.exposure);
+    if (!nextExposure || !ALLOWED_EXPOSURE_VALUES.has(nextExposure)) {
+      throw new CliError(`exposure invalido: "${nextConfig.exposure || ''}". Valores aceitos: ${formatAllowedValues(ALLOWED_EXPOSURE_VALUES)}. Docs: ${DOCS_CREATE_HTTP_URL}`);
+    }
+    nextConfig.exposure = nextExposure;
+  } else if (nextConfig.exposure !== undefined) {
+    throw new CliError('exposure deve ser informado apenas para projetos HTTP.');
+  }
+
+  const validatedConfig = validateCreateAutoscaling(nextConfig, nextPlan, nextTypeProject);
+
   return {
     plan: nextPlan,
     paymentMode: nextPaymentMode,
-    config: nextConfig,
+    config: validatedConfig,
   };
 }
 
@@ -2072,7 +2594,10 @@ function printWizardSummary(payload) {
   if (masked.description) lines.push(`  descricao: ${masked.description}`);
 
   if (masked.config.type_project === 'http') {
-    lines.push(`  http: porta ${masked.config.port} | instancias ${masked.config.instances} | storage ${masked.config.storage.capacity}Gi (${masked.config.storage.persistent ? 'persistente' : 'efemero'})`);
+    lines.push(`  http: exposicao ${masked.config.exposure} | porta ${masked.config.port} | instancias ${masked.config.instances} | storage ${masked.config.storage.capacity}Gi (${masked.config.storage.persistent ? 'persistente' : 'efemero'})`);
+    if (masked.config.autoscaling?.enabled) {
+      lines.push(`  auto-scaling: ${masked.config.instances}-${masked.config.autoscaling.max_instances} instancias | CPU ${masked.config.autoscaling.target_cpu_utilization_percent}% | memoria ${masked.config.autoscaling.target_memory_utilization_percent}%`);
+    }
     if (masked.config.github) {
       lines.push(`  github: ${masked.config.github.repository_owner}/${masked.config.github.repository_name}@${masked.config.github.branch} | runtime ${masked.config.github.runtime}@${masked.config.github.version}`);
     } else if (masked.config.image) {
@@ -2084,6 +2609,10 @@ function printWizardSummary(payload) {
     lines.push(`  banco: versao ${masked.config.version} | instancias ${masked.config.instances} | storage ${masked.config.storage.capacity}Gi`);
   }
 
+  if (masked.config.type_project === 'valkey') {
+    lines.push(`  Valkey: perfil ${masked.config.profile} | versao ${masked.config.version}${masked.config.storage ? ` | storage ${masked.config.storage.capacity}Gi persistente` : ' | sem storage persistente'}`);
+  }
+
   process.stdout.write(`${lines.join('\n')}\n`);
 }
 
@@ -2277,6 +2806,42 @@ async function buildHttpConfig({ plan, httpPlans, availableInstances }) {
     max: Math.max(1, Number(availableInstances?.[plan] || 1)),
   });
 
+  let autoscaling;
+  if (isAutoscalingEnabledForPlan(httpPlans, plan)) {
+    const enabled = await promptWizardBoolean({
+      label: 'Ativar auto-scaling',
+      docs: DOCS_CONFIGURATION_URL,
+      examples: ['sim', 'nao'],
+    });
+    promptWizardBoolean.ui.state.httpAutoscalingEnabled = enabled;
+    if (enabled) {
+      autoscaling = {
+        enabled: true,
+        max_instances: await promptWizardNumber({
+          label: 'Maximo de instancias do auto-scaling',
+          docs: DOCS_CONFIGURATION_URL,
+          examples: [String(Math.max(instances, 2))],
+          min: instances,
+          max: Math.max(instances, Number(availableInstances?.[plan] || instances)),
+        }),
+        target_cpu_utilization_percent: await promptWizardNumber({
+          label: 'CPU alvo do auto-scaling (%)',
+          docs: DOCS_CONFIGURATION_URL,
+          examples: ['70'],
+          min: 1,
+          max: 100,
+        }),
+        target_memory_utilization_percent: await promptWizardNumber({
+          label: 'Memoria alvo do auto-scaling (%)',
+          docs: DOCS_CONFIGURATION_URL,
+          examples: ['80'],
+          min: 1,
+          max: 100,
+        }),
+      };
+    }
+  }
+
   let storage;
   if (plan === 'free') {
     storage = { persistent: false, capacity: 1 };
@@ -2320,8 +2885,17 @@ async function buildHttpConfig({ plan, httpPlans, availableInstances }) {
     ],
   });
 
+  const exposure = await promptWizardSelect({
+    label: 'Exposicao HTTP',
+    docs: DOCS_CREATE_HTTP_URL,
+    examples: WIZARD_HTTP_EXPOSURE_OPTIONS,
+    options: WIZARD_HTTP_EXPOSURE_OPTIONS.map((value) => ({ value })),
+  });
+  promptWizardSelect.ui.state.httpExposure = exposure;
+
+  const isPublicExposure = exposure === 'public';
   const allowBlockIp = isIpAccessEnabled(httpPlans, plan);
-  const customWhitelist = allowBlockIp
+  const customWhitelist = isPublicExposure && allowBlockIp
     ? await promptWizardPairs({
       introLabel: 'Deseja configurar whitelist personalizada de entrada?',
       docs: DOCS_CONFIGURATION_URL,
@@ -2334,7 +2908,7 @@ async function buildHttpConfig({ plan, httpPlans, availableInstances }) {
     })
     : [];
 
-  const ingress_black_list = allowBlockIp
+  const ingress_black_list = isPublicExposure && allowBlockIp
     ? await promptWizardPairs({
       introLabel: 'Deseja adicionar blacklist de entrada?',
       docs: DOCS_CONFIGURATION_URL,
@@ -2347,7 +2921,7 @@ async function buildHttpConfig({ plan, httpPlans, availableInstances }) {
     })
     : [];
 
-  const subdomain = isSubdomainCustomizable(httpPlans, plan)
+  const subdomain = isPublicExposure && isSubdomainCustomizable(httpPlans, plan)
     ? await promptWizardText({
       label: 'Subdomain personalizado',
       examples: ['minha-api'],
@@ -2357,9 +2931,11 @@ async function buildHttpConfig({ plan, httpPlans, availableInstances }) {
 
   return {
     type_project: 'http',
+    exposure,
     ...(source === 'github' ? { github: await buildHttpGithubConfig() } : { image: await buildHttpImageConfig() }),
     port,
     instances,
+    ...(autoscaling ? { autoscaling } : {}),
     storage,
     envs,
     ...(subdomain ? { subdomain } : {}),
@@ -2428,6 +3004,65 @@ async function buildMariadbConfig() {
   };
 }
 
+async function buildValkeyConfig({ profile, plan, catalog }) {
+  const planDefinition = catalog.plans.find((entry) => entry.id === plan && entry.profile === profile);
+  const profileDefinition = catalog.profiles.find((entry) => entry.id === profile);
+  if (!planDefinition || !profileDefinition) {
+    throw new CliError('O catalogo Valkey nao possui o plano ou perfil selecionado. Tente novamente.');
+  }
+
+  let storage;
+  if (profileDefinition.persistence) {
+    storage = {
+      persistent: true,
+      capacity: await promptWizardNumber({
+        label: `Capacidade de armazenamento persistente (Gi, inclui ${planDefinition.included_storage_gb ?? 0} Gi)`,
+        docs: DOCS_CREATE_VALKEY_URL,
+        examples: [String(Math.max(1, planDefinition.included_storage_gb ?? 1)), '10', '20'],
+        min: 1,
+        max: 250,
+      }),
+    };
+  }
+
+  const whitelist = await promptWizardPairs({
+    introLabel: 'Deseja configurar acesso de rede para este projeto?',
+    docs: DOCS_CREATE_VALKEY_URL,
+    examples: ['sim', 'nao'],
+    stateKey: 'valkeyNetworkAccess',
+    itemLabels: [
+      { key: 'cidr', label: 'CIDR permitido', required: true, examples: ['203.0.113.0/24'], docs: DOCS_CREATE_VALKEY_URL },
+      { key: 'description', label: 'Descricao do acesso', required: true, examples: ['Aplicacao'], docs: DOCS_CREATE_VALKEY_URL },
+    ],
+  });
+
+  let blacklist = [];
+  if (whitelist.length > 0) {
+    blacklist = await promptWizardPairs({
+      introLabel: 'Deseja adicionar bloqueios de rede?',
+      docs: DOCS_CREATE_VALKEY_URL,
+      examples: ['sim', 'nao'],
+      itemLabels: [
+        { key: 'cidr', label: 'CIDR bloqueado', required: true, examples: ['198.51.100.0/24'], docs: DOCS_CREATE_VALKEY_URL },
+        { key: 'description', label: 'Descricao do bloqueio', required: true, examples: ['Bloqueio'], docs: DOCS_CREATE_VALKEY_URL },
+      ],
+    });
+  }
+
+  return {
+    type_project: 'valkey',
+    profile,
+    version: catalog.version,
+    ...(storage ? { storage } : {}),
+    ...(whitelist.length > 0 ? {
+      network_access: {
+        ingress_white_list: whitelist,
+        ingress_black_list: blacklist,
+      },
+    } : {}),
+  };
+}
+
 async function runProjectCreateWizard(session, flags) {
   const catalogs = await fetchWizardCatalogs(session, flags);
   const ui = createWizardUi();
@@ -2458,16 +3093,34 @@ async function runProjectCreateWizard(session, flags) {
     options: WIZARD_TYPE_PROJECT_OPTIONS.map((value) => ({ value })),
   });
   ui.state.typeProject = typeProject;
+  const valkeyCatalog = typeProject === 'valkey'
+    ? requireValkeyCatalog(unwrapData(await request(session, flags, 'GET', '/managed-services/catalog')))
+    : undefined;
+  const profile = typeProject === 'valkey'
+    ? await promptWizardSelect({
+      label: 'Perfil Valkey',
+      docs: DOCS_CREATE_VALKEY_URL,
+      examples: WIZARD_VALKEY_PROFILE_OPTIONS,
+      options: WIZARD_VALKEY_PROFILE_OPTIONS.map((value) => ({ value })),
+    })
+    : undefined;
+  ui.state.valkeyProfile = profile;
   const planOptions = typeProject === 'http'
     ? sortWizardOptions(catalogs.httpPlans
       .map((plan) => plan?.plan)
       .filter((plan) => WIZARD_HTTP_PLAN_OPTIONS.includes(plan) && Number(catalogs.availableInstances?.[plan] || 0) > 0), WIZARD_HTTP_PLAN_OPTIONS)
+    : typeProject === 'valkey'
+      ? valkeyCatalog.plans
+        .filter((planDefinition) => planDefinition.profile === profile)
+        .map((planDefinition) => planDefinition.id)
     : sortWizardOptions(catalogs.databasePlans
       .map((plan) => plan?.plan)
       .filter((plan) => WIZARD_DATABASE_PLAN_OPTIONS.includes(plan) && (typeProject !== 'mariadb' || plan !== 'db-free')), WIZARD_DATABASE_PLAN_OPTIONS);
   const plan = await promptWizardSelect({
     label: 'Plano',
-    docs: typeProject === 'http' ? DOCS_CREATE_HTTP_URL : DOCS_DATABASE_CONFIGURATION_URL,
+    docs: typeProject === 'http'
+      ? DOCS_CREATE_HTTP_URL
+      : typeProject === 'valkey' ? DOCS_CREATE_VALKEY_URL : DOCS_DATABASE_CONFIGURATION_URL,
     examples: [planOptions[0], planOptions.at(-1)],
     options: planOptions.map((value) => ({ value })),
   });
@@ -2475,6 +3128,7 @@ async function runProjectCreateWizard(session, flags) {
   if (typeProject === 'http') {
     ui.state.planAllowsBlockIp = isIpAccessEnabled(catalogs.httpPlans, plan);
     ui.state.planAllowsSubdomain = isSubdomainCustomizable(catalogs.httpPlans, plan);
+    ui.state.planAllowsAutoscaling = isAutoscalingEnabledForPlan(catalogs.httpPlans, plan);
   }
   const paymentMode = await promptWizardSelect({
     label: 'Modo de pagamento',
@@ -2492,6 +3146,8 @@ async function runProjectCreateWizard(session, flags) {
     });
   } else if (typeProject === 'postgresql') {
     config = await buildPostgresqlConfig({ plan, databasePlans: catalogs.databasePlans });
+  } else if (typeProject === 'valkey') {
+    config = await buildValkeyConfig({ profile, plan, catalog: valkeyCatalog });
   } else {
     config = await buildMariadbConfig();
   }
@@ -2507,7 +3163,9 @@ async function runProjectCreateWizard(session, flags) {
   printWizardSummary(payload);
   const confirmed = await promptWizardBoolean({
     label: 'Confirmar criacao do projeto',
-    docs: typeProject === 'http' ? DOCS_CREATE_HTTP_URL : DOCS_DATABASE_CONFIGURATION_URL,
+    docs: typeProject === 'http'
+      ? DOCS_CREATE_HTTP_URL
+      : typeProject === 'valkey' ? DOCS_CREATE_VALKEY_URL : DOCS_DATABASE_CONFIGURATION_URL,
     examples: ['sim', 'nao'],
   });
   if (!confirmed) return null;
@@ -2528,10 +3186,18 @@ async function handleProjectCreate(session, flags) {
   const plan = wizardPayload?.plan || flags.plan || await prompt('Plano');
   const paymentMode = wizardPayload?.payment_mode || flags.paymentMode || await prompt('Modo de pagamento');
   const config = wizardPayload?.config || await parseConfig(flags.config || await prompt('Config JSON ou @arquivo'));
-  const validated = validateCreateInput({ plan, paymentMode, config });
+  const typeProject = normalizeTypeProject(config?.type_project);
+  const valkeyCatalog = typeProject === 'valkey'
+    ? requireValkeyCatalog(unwrapData(await request(session, flags, 'GET', '/managed-services/catalog')))
+    : undefined;
+  if (flags.idempotencyKey !== undefined && !/^[A-Za-z0-9._-]{16,200}$/.test(String(flags.idempotencyKey))) {
+    throw new CliError('--idempotency-key deve ter entre 16 e 200 caracteres: letras, numeros, ponto, underscore ou hifen.');
+  }
+  const validated = validateCreateInput({ plan, paymentMode, config, valkeyCatalog });
 
   const payload = await request(session, flags, 'POST', '/project', {
     orgId,
+    headers: flags.idempotencyKey === undefined ? {} : { 'Idempotency-Key': String(flags.idempotencyKey) },
     body: {
       name,
       ...(description ? { description: String(description) } : {}),
@@ -2551,6 +3217,21 @@ async function handleProjectCreate(session, flags) {
     ...(project.domain ? [{ field: 'Dominio', value: formatPublicUrl(project.domain) }] : []),
     ...(project.api_key ? [{ field: 'API key', value: project.api_key }] : []),
   ];
+  if (validated.config.type_project === 'valkey') {
+    const service = project.managed_service || {};
+    rows.push(
+      { field: 'Perfil', value: service.profile || validated.config.profile },
+      { field: 'Host', value: service.host || '-' },
+      { field: 'Porta', value: service.port ?? '-' },
+      { field: 'TLS', value: service.tls === true ? 'sim' : 'nao' },
+    );
+    if (service.connection_string) {
+      rows.push({ field: 'String de conexao', value: service.connection_string });
+      process.stdout.write('Salve a string de conexao em um local seguro; ela pode nao ser exibida novamente.\n');
+    } else {
+      rows.push({ field: 'Credencial', value: 'nao retornada nesta resposta; use valkey credentials rotate' });
+    }
+  }
   process.stdout.write('\n');
   printTable(rows, [
     { label: 'Campo', value: (row) => row.field },
@@ -2654,6 +3335,33 @@ async function handleProjectImageSet(session, flags) {
   process.stdout.write('Imagem atualizada com sucesso.\n');
 }
 
+async function handleProjectExposureSet(session, flags) {
+  const projectId = requireProjectId(flags, 'project exposure set');
+  if (!projectId) return
+  const exposure = normalizeExposure(flags.exposure);
+
+  if (!ALLOWED_EXPOSURE_VALUES.has(exposure)) {
+    throw new CliError('exposure invalido. Use public ou private.');
+  }
+
+  const orgId = await resolveOrgId(session, flags);
+  const payload = await request(session, flags, 'PATCH', `/project/${projectId}/exposure`, {
+    orgId,
+    body: { exposure },
+  });
+
+  if (flags.json) return printJson(payload);
+
+  printTable([
+    { field: 'Exposicao', value: payload.exposure || exposure },
+    { field: 'Dominio', value: payload.domain ? formatPublicUrl(payload.domain) : '-' },
+    { field: 'Dominios customizados', value: asArray(payload.custom_domains).join(', ') || '-' },
+  ], [
+    { label: 'Campo', value: (row) => row.field },
+    { label: 'Valor', value: (row) => row.value },
+  ]);
+}
+
 async function getProjectEnvs(session, flags, projectId, orgId) {
   return asArray(unwrapData(await request(session, flags, 'GET', `/project/${projectId}/envs`, { orgId })));
 }
@@ -2760,6 +3468,366 @@ async function handleProjectInstancesSet(session, flags) {
   process.stdout.write(`Quantidade de instancias atualizada para ${instances}.\n`);
 }
 
+function parseAutoscalingPositiveInteger(value, flagName) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new CliError(`Informe ${flagName} <n> com um inteiro positivo.`);
+  }
+  return parsed;
+}
+
+function parseAutoscalingTargetPercent(value, flagName) {
+  const parsed = parseAutoscalingPositiveInteger(value, flagName);
+  if (parsed > 100) {
+    throw new CliError(`Informe ${flagName} entre 1 e 100.`);
+  }
+  return parsed;
+}
+
+function autoscalingFromProject(project) {
+  return project?.additional_info?.autoscaling || project?.autoscaling || { enabled: false };
+}
+
+function printAutoscaling(autoscaling) {
+  printTable([
+    {
+      status: autoscaling.enabled ? 'ativo' : 'inativo',
+      min: autoscaling.min_instances || '-',
+      max: autoscaling.max_instances || '-',
+      cpu: autoscaling.target_cpu_utilization_percent ? `${autoscaling.target_cpu_utilization_percent}%` : '-',
+      memory: autoscaling.target_memory_utilization_percent ? `${autoscaling.target_memory_utilization_percent}%` : '-',
+    },
+  ], [
+    { label: 'Status', value: (item) => item.status },
+    { label: 'Minimo', value: (item) => item.min },
+    { label: 'Maximo', value: (item) => item.max },
+    { label: 'CPU alvo', value: (item) => item.cpu },
+    { label: 'Memoria alvo', value: (item) => item.memory },
+  ]);
+}
+
+async function handleProjectAutoscaling(session, flags) {
+  const projectId = requireProjectId(flags, 'project autoscaling');
+  if (!projectId) return
+  const orgId = await resolveOrgId(session, flags);
+  const project = await getProject(session, flags, projectId, orgId);
+  const autoscaling = autoscalingFromProject(project);
+
+  if (flags.json) return printJson(autoscaling);
+  printAutoscaling(autoscaling);
+}
+
+async function handleProjectAutoscalingSet(session, flags) {
+  const projectId = requireProjectId(flags, 'project autoscaling set');
+  if (!projectId) return
+  if (flags.min === undefined || flags.max === undefined) {
+    printCommandHelpAndFail('project autoscaling set')
+    return
+  }
+
+  const minInstances = parseAutoscalingPositiveInteger(flags.min, '--min');
+  const maxInstances = parseAutoscalingPositiveInteger(flags.max, '--max');
+  if (maxInstances < minInstances) {
+    throw new CliError('Informe --max maior ou igual a --min.');
+  }
+
+  const body = {
+    enabled: true,
+    min_instances: minInstances,
+    max_instances: maxInstances,
+  };
+
+  if (flags.cpu !== undefined) {
+    body.target_cpu_utilization_percent = parseAutoscalingTargetPercent(flags.cpu, '--cpu');
+  }
+  if (flags.memory !== undefined) {
+    body.target_memory_utilization_percent = parseAutoscalingTargetPercent(flags.memory, '--memory');
+  }
+
+  const orgId = await resolveOrgId(session, flags);
+  const payload = await request(session, flags, 'PATCH', `/project/${projectId}/autoscaling`, {
+    orgId,
+    body,
+  });
+
+  if (flags.json) return printJson(payload);
+  process.stdout.write(`Auto-scaling atualizado: ${minInstances}-${maxInstances} instancias.\n`);
+}
+
+async function handleProjectAutoscalingDisable(session, flags) {
+  const projectId = requireProjectId(flags, 'project autoscaling disable');
+  if (!projectId) return
+
+  const orgId = await resolveOrgId(session, flags);
+  const payload = await request(session, flags, 'PATCH', `/project/${projectId}/autoscaling`, {
+    orgId,
+    body: { enabled: false },
+  });
+
+  if (flags.json) return printJson(payload);
+  process.stdout.write('Auto-scaling desativado.\n');
+}
+
+function printAutoscalingEvents(data) {
+  const directions = { scale_up: 'aumento', scale_down: 'reducao' };
+  const reasons = { increased_capacity: 'capacidade aumentada', reduced_capacity: 'capacidade reduzida' };
+  const events = asArray(data?.events);
+  printTable(events, [
+    { label: 'Quando', value: (event) => event.occurred_at || '-' },
+    { label: 'Direcao', value: (event) => directions[event.direction] || event.direction || '-' },
+    {
+      label: 'Instancias',
+      value: (event) => `${event.previous_instances ?? '-'} -> ${event.new_instances ?? '-'}`,
+    },
+    {
+      label: 'Limites',
+      value: (event) => {
+        const cpu = typeof event.current_cpu_utilization_percent === 'number' || typeof event.target_cpu_utilization_percent === 'number'
+          ? `CPU ${event.current_cpu_utilization_percent ?? '-'}%/${event.target_cpu_utilization_percent ?? '-'}%`
+          : null;
+        const memory = typeof event.current_memory_utilization_percent === 'number' || typeof event.target_memory_utilization_percent === 'number'
+          ? `MEM ${event.current_memory_utilization_percent ?? '-'}%/${event.target_memory_utilization_percent ?? '-'}%`
+          : null;
+        return [cpu, memory].filter(Boolean).join(' ');
+      },
+    },
+    { label: 'Motivo', value: (event) => reasons[event.reason] || event.reason || event.trigger_metric || '-' },
+  ]);
+
+  printPagination(data?.pagination, 'evento');
+}
+
+function isIsoDate(value) {
+  const text = String(value);
+  const match = text.match(/^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/);
+  if (!match || Number.isNaN(Date.parse(text))) return false;
+
+  const [, year, month, day, hour = '00', minute = '00', second = '00'] = match;
+  const calendarDate = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)));
+  return calendarDate.getUTCFullYear() === Number(year)
+    && calendarDate.getUTCMonth() === Number(month) - 1
+    && calendarDate.getUTCDate() === Number(day)
+    && Number(hour) <= 23
+    && Number(minute) <= 59
+    && Number(second) <= 59;
+}
+
+function validateProjectListFlags(flags, { maxLimit }) {
+  for (const key of ['from', 'to']) {
+    if (flags[key] !== undefined && !isIsoDate(flags[key])) {
+      throw new CliError(`Informe --${key} <iso> com uma data ISO valida.`);
+    }
+  }
+  if (flags.from !== undefined && flags.to !== undefined && Date.parse(String(flags.from)) > Date.parse(String(flags.to))) {
+    throw new CliError('Informe --from anterior ou igual a --to.');
+  }
+  for (const key of ['page', 'limit']) {
+    if (flags[key] === undefined) continue;
+    const value = Number(flags[key]);
+    if (!Number.isInteger(value) || value <= 0) {
+      throw new CliError(`Informe --${key} <n> com um inteiro positivo.`);
+    }
+    if (key === 'limit' && value > maxLimit) {
+      throw new CliError(`Informe --limit entre 1 e ${maxLimit}.`);
+    }
+  }
+}
+
+function printPagination(pagination, singular = 'item') {
+  if (!pagination) return;
+  const { page, total_pages: totalPages, total } = pagination;
+  process.stdout.write(`Pagina ${page} de ${totalPages || 1} - ${total} ${singular}(s)\n`);
+}
+
+function formatMoney(value, currency = 'brl') {
+  const amount = Number(value);
+  if (!Number.isFinite(amount)) return '-';
+  try {
+    return new Intl.NumberFormat('pt-BR', {
+      style: 'currency',
+      currency: String(currency || 'brl').toUpperCase(),
+    }).format(amount);
+  } catch {
+    return `${String(currency || 'brl').toUpperCase()} ${amount.toFixed(2)}`;
+  }
+}
+
+function printBillingUsage(data) {
+  const hours = asArray(data?.hours);
+  printTable(hours, [
+    { label: 'Inicio', value: (item) => item.hour_start || '-' },
+    { label: 'Fim', value: (item) => item.hour_end || '-' },
+    { label: 'Instancia-horas', value: (item) => item.compute_instance_hours ?? '-' },
+    { label: 'Armazenamento', value: (item) => item.storage_gb_hours === undefined ? '-' : `${item.storage_gb_hours} GB-h` },
+    { label: 'Computacao', value: (item) => formatMoney(item.compute_amount, item.currency) },
+    { label: 'Storage', value: (item) => formatMoney(item.storage_amount, item.currency) },
+    { label: 'Total', value: (item) => formatMoney(item.total_amount, item.currency) },
+    { label: 'Status', value: (item) => item.status || '-' },
+  ]);
+
+  if (data?.summary) {
+    const summary = data.summary;
+    process.stdout.write(`Resumo: computacao ${formatMoney(summary.compute_amount, summary.currency)}, armazenamento ${formatMoney(summary.storage_amount, summary.currency)}, total ${formatMoney(summary.total_amount, summary.currency)}\n`);
+  }
+  printPagination(data?.pagination, 'hora');
+}
+
+
+async function handleProjectAutoscalingEvents(session, flags) {
+  const projectId = requireProjectId(flags, 'project autoscaling events');
+  if (!projectId) return
+
+  if (flags.direction !== undefined && !['scale_up', 'scale_down'].includes(String(flags.direction))) {
+    throw new CliError('direction invalido. Use scale_up ou scale_down.');
+  }
+
+  validateProjectListFlags(flags, { maxLimit: 100 });
+
+  const orgId = await resolveOrgId(session, flags);
+  const query = buildQuery(flags, ['direction', 'from', 'to', 'page', 'limit']);
+  const data = unwrapData(await request(session, flags, 'GET', `/project/${projectId}/autoscaling/events${query}`, { orgId }));
+
+  if (flags.json) return printJson(data);
+  printAutoscalingEvents(data);
+}
+
+async function handleProjectBillingUsage(session, flags) {
+  const projectId = requireProjectId(flags, 'project billing usage');
+  if (!projectId) return;
+  validateProjectListFlags(flags, { maxLimit: 50 });
+  const orgId = await resolveOrgId(session, flags);
+  const query = buildQuery(flags, ['from', 'to', 'page', 'limit']);
+  const data = unwrapData(await request(session, flags, 'GET', `/project/${projectId}/billing/hourly-usage${query}`, { orgId }));
+
+  if (flags.json) return printJson(data);
+  printBillingUsage(data);
+}
+
+function printValkeyStatus(data) {
+  printTable([data], [
+    { label: 'Status', value: (service) => service.status || '-' },
+    { label: 'Perfil', value: (service) => service.profile || '-' },
+    { label: 'Versao', value: (service) => service.version || '-' },
+    { label: 'Persistente', value: (service) => service.persistence === true ? 'sim' : 'nao' },
+    { label: 'Instancias', value: (service) => service.instances ?? '-' },
+  ]);
+}
+
+function printValkeyConnection(data) {
+  printTable([data], [
+    { label: 'Host', value: (service) => service.host || '-' },
+    { label: 'Porta', value: (service) => service.port ?? '-' },
+    { label: 'Usuario', value: (service) => service.username || '-' },
+    { label: 'TLS', value: (service) => service.tls === true ? 'sim' : 'nao' },
+    { label: 'Conexao', value: (service) => service.connection_string || '-' },
+  ]);
+}
+
+function printValkeyRotation(data, { accepted = false } = {}) {
+  const rows = [
+    { field: accepted ? 'Operacao aceita' : 'Operacao', value: data.operation_id || '-' },
+    { field: 'Estado', value: data.state || '-' },
+  ];
+  if (data.connection_string) {
+    rows.push({ field: 'String de conexao', value: data.connection_string });
+    process.stdout.write('Salve a nova string de conexao em um local seguro; ela pode nao ser exibida novamente.\n');
+  }
+  printTable(rows, [
+    { label: 'Campo', value: (row) => row.field },
+    { label: 'Valor', value: (row) => row.value },
+  ]);
+}
+
+async function waitForValkeyRotation(session, flags, projectId, operationId, orgId) {
+  const intervalMs = parseSecondsOption(flags.interval, '--interval', { defaultValue: 2, min: 0.1 }) * 1000;
+  const timeoutMs = parseSecondsOption(flags.timeout, '--timeout', { defaultValue: 900, min: 1 }) * 1000;
+  const startedAt = Date.now();
+  let lastState = 'accepted';
+
+  while (true) {
+    const data = unwrapData(await request(
+      session,
+      flags,
+      'GET',
+      `/managed-services/${projectId}/credential-rotations/${operationId}`,
+      { orgId },
+    ));
+    lastState = data?.state || lastState;
+    if (lastState === 'completed') return data;
+    if (['failed', 'cancelled', 'canceled'].includes(lastState)) {
+      throw new CliError(`A renovacao de credencial terminou com estado ${lastState}. Operacao: ${operationId}.`);
+    }
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new CliError(`Timeout aguardando a renovacao ${operationId}. Ultimo estado: ${lastState}.`);
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, intervalMs));
+  }
+}
+
+async function handleValkeyStatus(session, flags) {
+  const projectId = requireProjectId(flags, 'valkey status');
+  if (!projectId) return;
+  const orgId = await resolveOrgId(session, flags);
+  const data = unwrapData(await request(session, flags, 'GET', `/managed-services/${projectId}/status`, { orgId }));
+  if (flags.json) return printJson(data);
+  printValkeyStatus(data);
+}
+
+async function handleValkeyConnection(session, flags) {
+  const projectId = requireProjectId(flags, 'valkey connection');
+  if (!projectId) return;
+  const orgId = await resolveOrgId(session, flags);
+  const data = unwrapData(await request(session, flags, 'GET', `/managed-services/${projectId}/connection`, { orgId }));
+  if (flags.json) return printJson(data);
+  printValkeyConnection(data);
+}
+
+async function handleValkeyCredentialStatus(session, flags) {
+  const projectId = requireProjectId(flags, 'valkey credentials status');
+  if (!projectId) return;
+  if (!flags.operation) {
+    printCommandHelpAndFail('valkey credentials status');
+    return;
+  }
+  const orgId = await resolveOrgId(session, flags);
+  const data = unwrapData(await request(
+    session,
+    flags,
+    'GET',
+    `/managed-services/${projectId}/credential-rotations/${flags.operation}`,
+    { orgId },
+  ));
+  if (flags.json) return printJson(data);
+  printValkeyRotation(data);
+}
+
+async function handleValkeyCredentialRotate(session, flags) {
+  const projectId = requireProjectId(flags, 'valkey credentials rotate');
+  if (!projectId) return;
+  const idempotencyKey = String(flags.idempotencyKey || randomUUID());
+  if (!/^[A-Za-z0-9._-]{16,200}$/.test(idempotencyKey)) {
+    throw new CliError('--idempotency-key deve ter entre 16 e 200 caracteres: letras, numeros, ponto, underscore ou hifen.');
+  }
+  const orgId = await resolveOrgId(session, flags);
+  const acceptedPayload = await request(session, flags, 'PATCH', `/managed-services/${projectId}/credentials`, {
+    orgId,
+    body: {},
+    headers: { 'Idempotency-Key': idempotencyKey },
+  });
+  const accepted = unwrapData(acceptedPayload);
+  if (!accepted?.operation_id) throw new CliError('A API nao retornou o identificador da renovacao de credencial.');
+
+  if (flags.wait) {
+    const completed = await waitForValkeyRotation(session, flags, projectId, accepted.operation_id, orgId);
+    if (flags.json) return printJson(completed);
+    printValkeyRotation(completed);
+    return;
+  }
+
+  if (flags.json) return printJson(acceptedPayload);
+  printValkeyRotation(accepted, { accepted: true });
+}
+
 function buildQuery(flags, allowedKeys) {
   const params = new URLSearchParams();
   for (const key of allowedKeys) {
@@ -2820,6 +3888,25 @@ async function getBuildLogs(session, flags, projectId, buildId, orgId, { cursor
   return unwrapData(await request(session, flags, 'GET', `/project/${projectId}/github/builds/${buildId}/logs${query}`, { orgId }))
 }
 
+function parseIntegerOption(value, flagName, { defaultValue, min, max }) {
+  if (value === undefined) return defaultValue;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < min || (max !== undefined && parsed > max)) {
+    const range = max === undefined ? `maior ou igual a ${min}` : `entre ${min} e ${max}`;
+    throw new CliError(`Informe ${flagName} com um inteiro ${range}.`);
+  }
+  return parsed;
+}
+
+function parseSecondsOption(value, flagName, { defaultValue, min }) {
+  if (value === undefined) return defaultValue;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < min) {
+    throw new CliError(`Informe ${flagName} com um numero maior ou igual a ${min}.`);
+  }
+  return parsed;
+}
+
 function printBuildLogs(logs) {
   for (const log of asArray(logs)) {
     process.stdout.write(`${buildLogLineOf(log)}\n`)
@@ -2838,10 +3925,10 @@ async function followBuildLogs(session, flags, projectId, buildId, orgId, {
   intervalSeconds = 5,
   timeoutSeconds = 900,
 } = {}) {
-  let cursor = Math.max(Number(initialCursor || 0), 0)
-  const pollLimit = Math.max(Number(limit || 200), 1)
-  const intervalMs = Math.max(Number(intervalSeconds || 5), 0.1) * 1000
-  const timeoutMs = Math.max(Number(timeoutSeconds || 900), 1) * 1000
+  let cursor = parseIntegerOption(initialCursor, '--cursor', { defaultValue: 0, min: 0 })
+  const pollLimit = parseIntegerOption(limit, '--limit', { defaultValue: 200, min: 1, max: 500 })
+  const intervalMs = parseSecondsOption(intervalSeconds, '--interval', { defaultValue: 5, min: 0.1 }) * 1000
+  const timeoutMs = parseSecondsOption(timeoutSeconds, '--timeout', { defaultValue: 900, min: 1 }) * 1000
   const startedAt = Date.now()
 
   while (true) {
@@ -2887,15 +3974,15 @@ async function handleBuildLogs(session, flags) {
   }
 
   const orgId = await resolveOrgId(session, flags);
-  const cursor = Math.max(Number(flags.cursor || 0), 0)
-  const limit = Math.max(Number(flags.limit || 200), 1)
+  const cursor = parseIntegerOption(flags.cursor, '--cursor', { defaultValue: 0, min: 0 })
+  const limit = parseIntegerOption(flags.limit, '--limit', { defaultValue: 200, min: 1, max: 500 })
 
   if (flags.follow) {
     return followBuildLogs(session, flags, projectId, buildId, orgId, {
       initialCursor: cursor,
       limit,
-      intervalSeconds: Number(flags.interval || 5),
-      timeoutSeconds: Number(flags.timeout || 900),
+      intervalSeconds: parseSecondsOption(flags.interval, '--interval', { defaultValue: 5, min: 0.1 }),
+      timeoutSeconds: parseSecondsOption(flags.timeout, '--timeout', { defaultValue: 900, min: 1 }),
     })
   }
 
@@ -2916,13 +4003,14 @@ async function handleDeployWatch(session, flags) {
   return followBuildLogs(session, flags, projectId, buildId, orgId, {
     initialCursor: 0,
     limit: 200,
-    intervalSeconds: Number(flags.interval || 5),
-    timeoutSeconds: Number(flags.timeout || 900),
+    intervalSeconds: parseSecondsOption(flags.interval, '--interval', { defaultValue: 5, min: 0.1 }),
+    timeoutSeconds: parseSecondsOption(flags.timeout, '--timeout', { defaultValue: 900, min: 1 }),
   })
 }
 
 async function main() {
   const { positional, flags } = parseArgs(process.argv.slice(2));
+  validateKnownFlags(flags);
   const [command, subcommand] = positional;
   const session = await readSession();
   try {
@@ -2966,16 +4054,30 @@ async function main() {
     if (command === 'orgs') return handleOrgs(session, flags);
     if (command === 'org' && subcommand === 'set') return handleOrgSet(session, flags);
     if (command === 'projects') return handleProjects(session, flags);
+    if (command === 'valkey' && subcommand === 'credentials' && positional.length === 2) {
+      process.stdout.write(commandHelp(['valkey', 'credentials']));
+      return;
+    }
+    if (command === 'valkey' && subcommand === 'status') return handleValkeyStatus(session, flags);
+    if (command === 'valkey' && subcommand === 'connection') return handleValkeyConnection(session, flags);
+    if (command === 'valkey' && subcommand === 'credentials' && positional[2] === 'rotate') return handleValkeyCredentialRotate(session, flags);
+    if (command === 'valkey' && subcommand === 'credentials' && positional[2] === 'status') return handleValkeyCredentialStatus(session, flags);
     if (command === 'project' && subcommand === 'info') return handleProjectInfo(session, flags);
     if (command === 'project' && subcommand === 'url') return handleProjectUrl(session, flags);
     if (command === 'project' && subcommand === 'logs') return handleProjectLogs(session, flags);
     if (command === 'project' && subcommand === 'metrics') return handleProjectMetrics(session, flags);
     if (command === 'project' && subcommand === 'network') return handleProjectNetwork(session, flags);
     if (command === 'project' && subcommand === 'image' && positional[2] === 'set') return handleProjectImageSet(session, flags);
+    if (command === 'project' && subcommand === 'exposure' && positional[2] === 'set') return handleProjectExposureSet(session, flags);
     if (command === 'project' && subcommand === 'envs') return handleProjectEnvs(session, flags);
     if (command === 'project' && subcommand === 'env' && positional[2] === 'add') return handleProjectEnvMutation(session, flags, 'add');
     if (command === 'project' && subcommand === 'env' && positional[2] === 'update') return handleProjectEnvMutation(session, flags, 'update');
     if (command === 'project' && subcommand === 'env' && positional[2] === 'remove') return handleProjectEnvMutation(session, flags, 'remove');
+    if (command === 'project' && subcommand === 'autoscaling' && positional[2] === 'set') return handleProjectAutoscalingSet(session, flags);
+    if (command === 'project' && subcommand === 'autoscaling' && positional[2] === 'disable') return handleProjectAutoscalingDisable(session, flags);
+    if (command === 'project' && subcommand === 'autoscaling' && positional[2] === 'events') return handleProjectAutoscalingEvents(session, flags);
+    if (command === 'project' && subcommand === 'autoscaling') return handleProjectAutoscaling(session, flags);
+    if (command === 'project' && subcommand === 'billing' && positional[2] === 'usage') return handleProjectBillingUsage(session, flags);
     if (command === 'project' && subcommand === 'instances' && positional[2] === 'set') return handleProjectInstancesSet(session, flags);
     if (command === 'project' && subcommand === 'instances') return handleProjectInstances(session, flags);
     if (command === 'builds' && subcommand === 'logs') return handleBuildLogs(session, flags);