auroq-os 2.8.0 → 2.8.2

package/lib/infisical.js

@@ -0,0 +1,1271 @@
+'use strict';
+
+/**
+ * Auroq OS — Conexao Infisical (cofre gratis, rota B)
+ *
+ * Para o aluno que nao quer pagar o 1Password. O aluno so cria a conta no Infisical (gratis) e entra pelo
+ * navegador (`infisical login`, que abre sozinho). O resto e daqui: garante o CLI do Infisical, cria o
+ * projeto "Auroq", cria uma identidade de maquina do PROJETO (so enxerga esse projeto), com Universal Auth e
+ * uma chave sem validade, grava a chave neste computador e testa num terminal novo (grava, le e apaga um
+ * segredo de teste). A sessao do aluno (que expira em dias) so existe durante a configuracao; depois quem
+ * trabalha e a identidade, que renova o acesso sozinha a cada uso.
+ *
+ * O client secret nasce e e gravado dentro deste processo: nunca e impresso nem passa por argumento de linha
+ * de comando. Depois de gravado ele e uma variavel de ambiente do aluno (mesmo arquivo de ambiente da rota A):
+ * por isso o Ops nunca roda `env` nem abre esse arquivo.
+ *
+ * @module auroq-os/infisical
+ */
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs-extra');
+const { execSync, execFileSync, spawnSync } = require('child_process');
+const op = require('./onepassword');
+const apiLib = require('./infisical-api');
+const cliLib = require('./infisical-cli');
+
+const PURPLE = '\x1b[38;2;120;80;200m';
+const GOLD = '\x1b[38;2;245;158;11m';
+const CYAN = '\x1b[38;2;34;211;238m';
+const GREEN = '\x1b[38;2;52;211;153m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+
+function log(msg) { console.log(`  ${msg}`); }
+function step(msg) { console.log(`\n  ${CYAN}▸${RESET} ${msg}`); }
+function ok(msg) { console.log(`  ${GREEN}✓${RESET} ${msg}`); }
+function warn(msg) { console.log(`  ${GOLD}!${RESET} ${msg}`); }
+function err(msg) { console.log(`  ${PURPLE}✗${RESET} ${msg}`); }
+
+const CLIENT_ID_VAR = 'AUROQ_INFISICAL_CLIENT_ID';
+const CLIENT_SECRET_VAR = 'AUROQ_INFISICAL_CLIENT_SECRET';
+const ENV_COMMENT = '# Infisical - identidade do agente (gravado pelo Auroq OS)';
+const PROJECT_NAME = 'Auroq';
+const PROJECT_SLUG = 'auroq';
+const IDENTITY_NAME = 'Auroq';
+const ENV_SLUG = 'prod';
+const TEST_SECRET = 'AUROQ_TESTE';
+const KEY_PREFIX = 'Auroq OS - ';
+const MAX_WAIT_SECONDS = 570; // o CLI espera o navegador por 10 min; a ferramenta do agente corta em 10 min
+const DEFAULT_WAIT_SECONDS = 540;
+const MIN_WAIT_SECONDS = 5; // piso: tempo 0 no runProcess significa "sem limite", e --esperar 0 so quer a URL na hora
+const LOGIN_RETRY_WAITS_MS = [20000, 35000]; // nunca 3 falhas em 30 s: a identidade trava por 5 min
+const LOGIN_LOCK_WINDOW_MS = 30000; // o contador de falhas de login da identidade zera 30 s depois da ULTIMA falha
+const EXIT_CODE = { ok: 0, aguardando: 0, erro: 1 };
+
+// ─── Etapas ──────────────────────────────────────────────
+
+const ETAPAS = ['conta', 'cli', 'login', 'projeto', 'identidade', 'teste', 'pronto'];
+const ETAPA_NOME = {
+  conta: 'conta no Infisical (entrou pelo navegador)',
+  cli: 'ferramenta infisical instalada',
+  login: 'login no navegador',
+  projeto: 'projeto Auroq',
+  identidade: 'chave do agente (identidade) criada e guardada',
+  teste: 'teste em terminal novo (grava, le e apaga)',
+  pronto: 'pronto',
+};
+
+function emptyEtapas() {
+  return Object.fromEntries(ETAPAS.map((e) => [e, 'pendente']));
+}
+
+function stateFile() {
+  return path.join(op.auroqDir(), 'infisical-etapas.json');
+}
+
+function configFile() {
+  return path.join(op.auroqDir(), 'infisical.json');
+}
+
+/** Estado salvo (ou null). Nunca lanca: arquivo ausente ou estragado = comeca do zero. */
+function readState() {
+  try {
+    const data = JSON.parse(fs.readFileSync(stateFile(), 'utf8'));
+    if (!data || typeof data !== 'object' || data.versao !== 1 || !data.etapas) return null;
+    const etapas = emptyEtapas();
+    for (const e of ETAPAS) if (data.etapas[e] === 'feito') etapas[e] = 'feito';
+    return { versao: 1, etapas, ultimo: data.ultimo || null, atualizado_em: data.atualizado_em || null };
+  } catch {
+    return null;
+  }
+}
+
+function writeState(state) {
+  try {
+    op.writeFileAtomic(stateFile(), `${JSON.stringify(state, null, 2)}\n`);
+  } catch {
+    /* o estado e conforto, nunca motivo para falhar a conexao */
+  }
+}
+
+/** Config sem segredo (dominio, projeto, ambiente, identidade, caminho do CLI). */
+function readConfig() {
+  try {
+    const data = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
+    if (!data || typeof data !== 'object' || data.versao !== 1) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+function writeConfig(cfg) {
+  const merged = { ...(readConfig() || {}), ...cfg, versao: 1 };
+  op.writeFileAtomic(configFile(), `${JSON.stringify(merged, null, 2)}\n`);
+  return merged;
+}
+
+function nextStage(etapas) {
+  return ETAPAS.find((e) => etapas[e] !== 'feito') || null;
+}
+
+function makeProgress(d) {
+  const prev = d.state.read();
+  const etapas = prev ? { ...prev.etapas } : emptyEtapas();
+  return {
+    etapas,
+    mark(...stages) { for (const e of stages) etapas[e] = 'feito'; },
+    reset(...stages) { for (const e of stages) etapas[e] = 'pendente'; },
+    all() { this.mark(...ETAPAS); },
+    save(result) {
+      d.state.write({
+        versao: 1,
+        atualizado_em: new Date(d.now()).toISOString(),
+        etapas: { ...etapas },
+        proxima: nextStage(etapas),
+        ultimo: result ? { status: result.status, codigo: result.codigo } : null,
+      });
+    },
+  };
+}
+
+// ─── Textos e helpers puros ──────────────────────────────
+
+function fim(status, codigo, mensagem, extra = {}) {
+  return { status, codigo, mensagem, ...extra };
+}
+
+/** Uma linha so, sem JWT nem client secret. */
+function clean(text, max = 300) {
+  // corta ANTES do redact: as regex dele custam N^2 em texto longo, e o que passa de 4000 caracteres nunca apareceria
+  const bounded = String(text === undefined || text === null ? '' : text).slice(0, 4000);
+  return apiLib.redact(op.oneLine(apiLib.redact(bounded), max));
+}
+
+function parseArgs(argv) {
+  const args = Array.isArray(argv) ? argv : [];
+  const opts = { rotacionar: false, agente: false, estado: false, regiao: null, dominio: null, esperar: null };
+  for (let i = 0; i < args.length; i++) {
+    const a = String(args[i]);
+    if (a === '--rotacionar') opts.rotacionar = true;
+    else if (a === '--agente') opts.agente = true;
+    else if (a === '--estado') opts.estado = true;
+    else if (a === '--regiao' && args[i + 1] && !String(args[i + 1]).startsWith('--')) opts.regiao = String(args[++i]).toLowerCase();
+    else if (a.startsWith('--regiao=')) opts.regiao = a.slice('--regiao='.length).toLowerCase() || null;
+    else if (a === '--dominio' && args[i + 1] && !String(args[i + 1]).startsWith('--')) opts.dominio = String(args[++i]);
+    else if (a.startsWith('--dominio=')) opts.dominio = a.slice('--dominio='.length) || null;
+    else if (a === '--esperar' && args[i + 1] && !String(args[i + 1]).startsWith('--')) opts.esperar = Number(args[++i]);
+    else if (a.startsWith('--esperar=')) opts.esperar = Number(a.slice('--esperar='.length));
+  }
+  if (opts.esperar !== null && (!Number.isFinite(opts.esperar) || opts.esperar < 0)) opts.esperar = null;
+  return opts;
+}
+
+/** Dominio do Infisical: --dominio > --regiao > o gravado na config > US. Devolve { dominio, regiao } ou null (invalido). */
+function resolveDomain(opts, saved) {
+  if (opts.dominio) {
+    const dominio = apiLib.normalizeDomain(opts.dominio);
+    return dominio ? { dominio, regiao: 'custom' } : null;
+  }
+  if (opts.regiao) {
+    // so as regioes da lista: 'constructor' e '__proto__' existem em qualquer objeto, mas nao sao regioes
+    const known = typeof opts.regiao === 'string' && Object.prototype.hasOwnProperty.call(apiLib.REGIONS, opts.regiao);
+    return known ? { dominio: apiLib.REGIONS[opts.regiao], regiao: opts.regiao } : null;
+  }
+  if (saved && saved.dominio) {
+    const dominio = apiLib.normalizeDomain(saved.dominio);
+    if (dominio) return { dominio, regiao: saved.regiao || 'custom' };
+  }
+  return { dominio: apiLib.REGIONS.us, regiao: 'us' };
+}
+
+/** Nome do computador na descricao da chave: so para o aluno LER. Quem identifica a chave e o marcador com o id. */
+function hostLabel(hostname) {
+  const safe = String(hostname || 'computador').replace(/[^A-Za-z0-9 ._-]/g, '').trim().slice(0, 40);
+  return safe || 'computador';
+}
+
+const COMPUTER_ID_RE = /^[0-9a-f]{10}$/;
+
+/**
+ * Marcador do computador na descricao da chave (` [id] - `). A rotacao so revoga chaves que tem o marcador DESTE
+ * computador: o nome do host nao serve (dois Macs com o mesmo nome padrao, ou um host que mudou de nome).
+ */
+function keyMarker(computerId) {
+  if (!COMPUTER_ID_RE.test(String(computerId || ''))) throw new TypeError('id do computador invalido');
+  return ` [${computerId}] - `;
+}
+
+/** "Auroq OS - <host> [<id>] - <data>". O host e so para leitura humana. */
+function keyDescription(hostname, nowMs, computerId) {
+  return `${KEY_PREFIX}${hostLabel(hostname)}${keyMarker(computerId)}${new Date(nowMs).toISOString().slice(0, 10)}`;
+}
+
+/** Chaves (nao revogadas) que sao DESTE computador: descricao do Auroq OS com o marcador do id. */
+function ownKeys(secrets, computerId) {
+  const marker = keyMarker(computerId);
+  return (Array.isArray(secrets) ? secrets : []).filter((s) => s && !s.revoked && String(s.description || '').startsWith(KEY_PREFIX) && String(s.description).includes(marker));
+}
+
+/** Identificador do computador que o sistema ja tem (nao muda com o nome do host). null se nao der para ler. */
+function machineSeed(env = {}) {
+  const platform = env.platform || process.platform;
+  const exec = env.execFileSync || execFileSync;
+  const read = env.readFileSync || fs.readFileSync;
+  try {
+    if (platform === 'darwin') {
+      const text = String(exec('/usr/sbin/ioreg', ['-rd1', '-c', 'IOPlatformExpertDevice'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }));
+      const m = /"IOPlatformUUID"\s*=\s*"([0-9A-Fa-f-]{16,64})"/.exec(text);
+      return m ? m[1].toLowerCase() : null;
+    }
+    if (platform === 'win32') {
+      const text = String(exec('reg', ['query', 'HKLM\\SOFTWARE\\Microsoft\\Cryptography', '/v', 'MachineGuid'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000, windowsHide: true }));
+      const m = /MachineGuid\s+REG_SZ\s+([0-9A-Fa-f-]{16,64})/.exec(text);
+      return m ? m[1].toLowerCase() : null;
+    }
+    for (const file of ['/etc/machine-id', '/var/lib/dbus/machine-id']) {
+      try {
+        const id = String(read(file, 'utf8')).trim();
+        if (/^[0-9a-fA-F-]{16,64}$/.test(id)) return id.toLowerCase();
+      } catch { /* tenta o proximo */ }
+    }
+  } catch { /* sem leitura do sistema: cai no id guardado */ }
+  return null;
+}
+
+/**
+ * Id estavel e curto (10 hex) deste computador PARA ESTE USUARIO: hash do id que o sistema ja tem (nunca o
+ * valor cru) + usuario. Nao depende do nome do host (que muda com DHCP ou quando o aluno renomeia o computador)
+ * nem do infisical.json. Se o sistema nao informar nada, usa um id aleatorio guardado no infisical.json.
+ */
+function localComputerId(d, env = {}) {
+  const crypto = require('crypto');
+  const seed = (d && typeof d.machineSeed === 'function' ? d.machineSeed() : machineSeed(env));
+  if (seed) {
+    let user = '';
+    try { user = os.userInfo().username; } catch { user = ''; }
+    return crypto.createHash('sha256').update(`auroq-os|infisical|${seed}|${user}`).digest('hex').slice(0, 10);
+  }
+  const cfg = d && d.config ? d.config.read() : null;
+  if (cfg && COMPUTER_ID_RE.test(String(cfg.instalacaoId || ''))) return cfg.instalacaoId;
+  const id = crypto.randomBytes(5).toString('hex');
+  if (d && d.config) d.config.write({ instalacaoId: id });
+  return id;
+}
+
+// ─── Credenciais no computador (mesmo arquivo de ambiente da rota A) ────────
+
+const CRED_LINE_RE = /^\s*(export\s+)?AUROQ_INFISICAL_CLIENT_(ID|SECRET)=/;
+
+/** clientId do Universal Auth: UUID. Nada fora desse formato entra no arquivo de ambiente (o shell executa o que estiver la). */
+function isClientId(value) {
+  return typeof value === 'string' && /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(value);
+}
+
+function isCredPair(creds) {
+  return Boolean(creds) && isClientId(creds.clientId) && apiLib.isClientSecretShape(creds.clientSecret);
+}
+
+function upsertEnvFileContent(existing, creds) {
+  // Defesa final: o arquivo e lido pelo shell de todo terminal novo. Valor fora do formato nunca entra.
+  if (!isCredPair(creds)) throw new Error('credencial em formato inesperado');
+  const kept = String(existing || '')
+    .split('\n')
+    .filter((line) => !CRED_LINE_RE.test(line) && line.trim() !== ENV_COMMENT);
+  while (kept.length > 0 && kept[kept.length - 1].trim() === '') kept.pop();
+  kept.push('');
+  kept.push(ENV_COMMENT);
+  kept.push(`export ${CLIENT_ID_VAR}='${creds.clientId}'`);
+  kept.push(`export ${CLIENT_SECRET_VAR}='${creds.clientSecret}'`);
+  kept.push('');
+  return kept.join('\n');
+}
+
+/** Le as credenciais da(s) LINHA(S) que o Auroq grava (ultima definicao vence). Aspas simples, duplas ou nenhuma. */
+function parseEnvFileCreds(content) {
+  const found = { clientId: null, clientSecret: null };
+  for (const line of String(content || '').split('\n')) {
+    const m = line.match(/^\s*(?:export\s+)?AUROQ_INFISICAL_CLIENT_(ID|SECRET)=(.*)$/);
+    if (!m) continue;
+    const value = m[2].trim().replace(/^(['"])(.*)\1$/, '$2') || null;
+    if (m[1] === 'ID') found.clientId = value;
+    else found.clientSecret = value;
+  }
+  return found.clientId || found.clientSecret ? found : null;
+}
+
+/** Linha do aluno que define a variavel de outro jeito (ex.: busca no Keychain): o valor nao e uma credencial. */
+function hasDynamicCredDefinition(content) {
+  return String(content || '').split('\n').some((line) => {
+    const m = line.match(/^\s*(?:export\s+)?AUROQ_INFISICAL_CLIENT_(ID|SECRET)=(.*)$/);
+    if (!m) return false;
+    const value = m[2].trim().replace(/^(['"])(.*)\1$/, '$2');
+    if (value === '') return false;
+    return m[1] === 'ID' ? !isClientId(value) : !apiLib.isClientSecretShape(value);
+  });
+}
+
+/**
+ * Por que NAO da para gravar as credenciais no arquivo de ambiente (ou null se da). Roda ANTES de criar a
+ * chave, porque ela so aparece uma vez. Mesmas razoes da rota A: atalho, arquivo no git, linha propria do
+ * aluno que define a variavel de outro jeito, sem permissao. No Windows vai para variavel do usuario.
+ */
+function envFileProblem() {
+  if (process.platform === 'win32') return null;
+  const file = op.envFilePath();
+  const name = path.basename(file);
+  let st = null;
+  try { st = fs.lstatSync(file); } catch { /* ainda nao existe: tudo bem */ }
+  if (st && st.isSymbolicLink()) {
+    return `${name} e um atalho (link) para outro lugar; nao gravo a chave nele para ela nao ir parar num repositorio`;
+  }
+  if (st && op.isTrackedByGit(file)) {
+    return `${name} esta versionado no git; nao gravo a chave nele para ela nao ir parar no GitHub`;
+  }
+  if (st) {
+    let content = '';
+    try { content = fs.readFileSync(file, 'utf8'); } catch { return `${name} nao pode ser lido`; }
+    if (hasDynamicCredDefinition(content)) {
+      return `${name} ja define ${CLIENT_ID_VAR} ou ${CLIENT_SECRET_VAR} de outro jeito (uma linha sua); nao vou apagar a sua linha`;
+    }
+  }
+  try {
+    fs.accessSync(st ? file : path.dirname(file), fs.constants.W_OK);
+  } catch {
+    return `${name} (ou a pasta dele) nao aceita escrita`;
+  }
+  return null;
+}
+
+function persistCreds(creds) {
+  if (!isCredPair(creds)) throw new Error('credencial em formato inesperado');
+  if (process.platform === 'win32') {
+    // Variavel de ambiente do usuario: os valores passam por env do processo, nunca por argv
+    const psEnv = { stdio: 'pipe', env: { ...process.env, AUROQ_TMP_ID: creds.clientId, AUROQ_TMP_SECRET: creds.clientSecret } };
+    try {
+      execSync(
+        `powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('${CLIENT_ID_VAR}', $env:AUROQ_TMP_ID, 'User'); [Environment]::SetEnvironmentVariable('${CLIENT_SECRET_VAR}', $env:AUROQ_TMP_SECRET, 'User')"`,
+        psEnv,
+      );
+    } catch {
+      // Modo restrito (Constrained Language): chamadas .NET bloqueadas; o registro via cmdlet e permitido
+      execSync(
+        `powershell -NoProfile -Command "Set-ItemProperty -Path 'HKCU:\\Environment' -Name '${CLIENT_ID_VAR}' -Value $env:AUROQ_TMP_ID; Set-ItemProperty -Path 'HKCU:\\Environment' -Name '${CLIENT_SECRET_VAR}' -Value $env:AUROQ_TMP_SECRET"`,
+        psEnv,
+      );
+      warn('Gravado via registro (modo restrito detectado). Se o terminal novo nao enxergar, reinicie o computador uma vez.');
+    }
+    return 'variaveis de ambiente do usuario (Windows)';
+  }
+  const envFile = op.envFilePath();
+  const problem = envFileProblem();
+  if (problem) throw new Error(problem);
+  const existing = fs.existsSync(envFile) ? fs.readFileSync(envFile, 'utf8') : '';
+  op.writeFileAtomic(envFile, upsertEnvFileContent(existing, creds));
+  return envFile.replace(os.homedir(), '~');
+}
+
+/** O que um terminal NOVO vai enxergar: arquivo de ambiente (Mac/Linux) ou variaveis do usuario (Windows). */
+function readPersistedCreds() {
+  if (process.platform === 'win32') {
+    const run = (script) => {
+      try {
+        return execFileSync('powershell', ['-NoProfile', '-Command', script], { stdio: 'pipe', encoding: 'utf8' }).trim();
+      } catch {
+        return '';
+      }
+    };
+    const get = (name) => run(`[Environment]::GetEnvironmentVariable('${name}', 'User')`)
+      || run(`(Get-ItemProperty -Path 'HKCU:\\Environment' -Name '${name}' -ErrorAction SilentlyContinue).${name}`);
+    const clientId = get(CLIENT_ID_VAR);
+    const clientSecret = get(CLIENT_SECRET_VAR);
+    return clientId && clientSecret ? { clientId, clientSecret } : null;
+  }
+  try {
+    const file = op.envFilePath();
+    const parsed = fs.existsSync(file) ? parseEnvFileCreds(fs.readFileSync(file, 'utf8')) : null;
+    return parsed && parsed.clientId && parsed.clientSecret ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Credenciais que ja existem, na ordem de conferir: as GRAVADAS no computador primeiro e, se forem outras, as do
+ * ambiente deste processo. A gravada manda (como no `segredo`): um terminal/Claude aberto antes de uma troca de chave
+ * ainda tem a chave ANTIGA no ambiente (no Windows o ambiente do processo nunca atualiza), e ela nao pode passar na
+ * frente da nova: seria regravada por cima dela e revogada em seguida.
+ */
+function currentCreds(d) {
+  const candidates = [];
+  const persisted = d.readPersistedCreds();
+  if (isCredPair(persisted)) candidates.push({ creds: persisted, origem: 'gravada' });
+  const fromEnv = { clientId: d.env[CLIENT_ID_VAR], clientSecret: d.env[CLIENT_SECRET_VAR] };
+  if (isCredPair(fromEnv) && !candidates.some((c) => c.creds.clientId === fromEnv.clientId && c.creds.clientSecret === fromEnv.clientSecret)) {
+    candidates.push({ creds: fromEnv, origem: 'ambiente' });
+  }
+  return candidates;
+}
+
+// ─── Dependencias reais (trocaveis nos testes) ───────────
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+/** Ambiente de um terminal NOVO: sem as credenciais deste processo (so o arquivo/variavel do usuario conta). */
+function freshEnvBase() {
+  const env = { ...process.env };
+  for (const k of Object.keys(env)) {
+    if (k.toUpperCase() === CLIENT_ID_VAR || k.toUpperCase() === CLIENT_SECRET_VAR) delete env[k];
+  }
+  return env;
+}
+
+/**
+ * "Terminal novo": no Mac/Linux abre um shell de verdade, que le sozinho o arquivo de ambiente, e roda o
+ * proprio auroq-os (o mesmo comando que os agentes vao usar). No Windows um processo filho herda o ambiente
+ * deste, entao usa o valor que um terminal novo leria (variavel do usuario).
+ */
+function runInFreshShell(args, { input = '' } = {}) {
+  const bin = path.join(__dirname, '..', 'bin', 'auroq-os.js');
+  const run = (file, fileArgs, env) => {
+    const r = spawnSync(file, fileArgs, {
+      encoding: 'utf8', env, input, timeout: 90000, maxBuffer: 16 * 1024 * 1024, windowsHide: true,
+    });
+    return {
+      ok: !r.error && r.status === 0,
+      status: r.status,
+      stdout: r.stdout || '',
+      stderr: r.stderr || '',
+      timedOut: !!(r.error && r.error.code === 'ETIMEDOUT'),
+    };
+  };
+  if (process.platform === 'win32') {
+    const persisted = readPersistedCreds();
+    const env = freshEnvBase();
+    if (persisted) {
+      env[CLIENT_ID_VAR] = persisted.clientId;
+      env[CLIENT_SECRET_VAR] = persisted.clientSecret;
+    }
+    return run(process.execPath, [bin, ...args], env);
+  }
+  const { bin: shell, flag } = op.freshShellFor(op.envFilePath());
+  const line = [process.execPath, bin, ...args].map(shellQuote).join(' ');
+  return run(shell, [flag, line], freshEnvBase());
+}
+
+/** Um terminal novo enxerga as credenciais certas? (compara so um resumo; nada e impresso) */
+function freshShellSees(creds) {
+  const crypto = require('crypto');
+  const digest = (c) => crypto.createHash('sha256').update(`${c.clientId}\n${c.clientSecret}`).digest('hex');
+  if (process.platform === 'win32') {
+    const p = readPersistedCreds();
+    return Boolean(p) && digest(p) === digest(creds);
+  }
+  const script = `const c=require('crypto');process.stdout.write(c.createHash('sha256').update((process.env.${CLIENT_ID_VAR}||'')+'\\n'+(process.env.${CLIENT_SECRET_VAR}||'')).digest('hex'))`;
+  const { bin: shell, flag } = op.freshShellFor(op.envFilePath());
+  const line = [process.execPath, '-e', script].map(shellQuote).join(' ');
+  const r = spawnSync(shell, [flag, line], { encoding: 'utf8', env: freshEnvBase(), input: '', timeout: 60000 });
+  return !r.error && r.status === 0 && String(r.stdout || '').trim().endsWith(digest(creds));
+}
+
+function makeDefaultCliFacade() {
+  const cliDeps = cliLib.makeDefaultCliDeps ? cliLib.makeDefaultCliDeps() : {};
+  return {
+    find: (preferred) => cliLib.findCli(cliDeps, { preferred }),
+    install: () => cliLib.installCli(cliDeps),
+    loginStatus: (cli) => cliLib.loginStatus(cliDeps, cli),
+    browserLogin: (cli, o) => cliLib.browserLogin(cliDeps, cli, o),
+    getUserToken: (cli) => cliLib.getUserToken(cliDeps, cli),
+    logout: (cli) => cliLib.logoutProfile(cliDeps, cli),
+  };
+}
+
+function makeDefaultDeps() {
+  return {
+    platform: process.platform,
+    env: process.env,
+    now: () => Date.now(),
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    hostname: () => os.hostname(),
+    lock: op.makeLock('infisical.lock'),
+    state: { read: readState, write: writeState },
+    config: { read: readConfig, write: writeConfig },
+    api: (baseUrl, token) => apiLib.createClient({ baseUrl, token }),
+    ops: apiLib.ops,
+    cli: makeDefaultCliFacade(),
+    envFileProblem,
+    persistCreds,
+    readPersistedCreds,
+    runFresh: runInFreshShell,
+    freshSees: freshShellSees,
+    registerCofre: (tipo) => {
+      try { require('./cofre').registrar(tipo); } catch { /* o registro e conforto: nunca falha a conexao */ }
+    },
+    out: { log, step, ok, warn, err, tick: () => process.stdout.write('.') },
+  };
+}
+
+// ─── Fluxo ───────────────────────────────────────────────
+
+/** Traduz um erro da API (codigo da infisical-api) no resultado da conexao. `padrao` e o codigo quando nao ha um mais especifico. */
+function apiFail(res, padrao, o) {
+  const detalhe = clean(res.mensagem || '');
+  const sufixo = detalhe ? ` (${detalhe})` : '';
+  switch (res.codigo) {
+    case 'rede':
+    case 'tempo':
+      return fim('erro', 'rede', `Sem conexao com o Infisical${sufixo}.`);
+    case 'limite':
+      return fim('erro', 'limite', `O Infisical limitou os acessos por enquanto (limite de uso)${sufixo}. Espere alguns minutos e rode de novo.`);
+    case 'bloqueada':
+      return fim('erro', 'bloqueada', 'A chave do agente ficou bloqueada por alguns minutos (varias tentativas seguidas). Espere uns 6 minutos e rode de novo.');
+    case 'limite-plano':
+      return fim('erro', 'limite-plano', `O plano gratis do Infisical tem 5 vagas e elas acabaram: voce conta 1 e o agente Auroq (a identidade, uma so) conta 1. Apagar uma chave nao libera vaga. Para liberar, apague no painel do Infisical uma identidade de maquina (machine identity) que voce nao usa e rode de novo${sufixo}.`);
+    case 'plano-restringe':
+      return fim('erro', 'plano-restringe', `O plano gratis do Infisical nao permitiu ${o && o.acao ? o.acao : 'essa etapa'}${sufixo}. Isso NAO e falta de vaga: nao apague nada no painel. Nao consigo contornar sozinho; se o 1Password for uma opcao para voce, use ele como cofre, ou peca ajuda ao Arcano com o codigo plano-restringe.`);
+    case 'sem-permissao':
+      return fim('erro', 'sem-permissao', `Sua conta do Infisical nao tem permissao para ${o && o.acao ? o.acao : 'essa etapa'}${sufixo}. Encerrei a sessao: se a conta ou a organizacao for a errada, rode de novo e escolha outra no navegador.`);
+    case 'sessao-expirada':
+      return fim('aguardando', 'login-no-navegador', 'A sessao do navegador expirou. Rode de novo para entrar outra vez no Infisical.', { reentrar: true });
+    default:
+      break;
+  }
+  if (padrao === 'falha-projeto') return fim('erro', 'falha-projeto', `Nao consegui preparar o projeto Auroq no Infisical${sufixo}.`);
+  if (padrao === 'falha-identidade') return fim('erro', 'falha-identidade', `Nao consegui criar a identidade do agente no Infisical${sufixo}.`);
+  if (padrao === 'falha-chave') return fim('erro', 'falha-chave', `Nao consegui criar a chave do agente no Infisical${sufixo}.`);
+  return fim('erro', 'falha', `Resposta inesperada do Infisical${sufixo}.`);
+}
+
+/**
+ * Falhas de login (chave recusada) que ESTA execucao ja causou na identidade. O Infisical trava a identidade por
+ * 5 minutos na 3a falha seguida com menos de 30 s entre elas (ate com a chave certa): conferir uma chave morta
+ * conta como uma delas, entao o teste da chave nova tem de respeitar o que ja foi gasto.
+ */
+function newLoginLedger() {
+  return { count: 0, lastAt: 0 };
+}
+
+function noteLoginFailure(d, ledger) {
+  const now = d.now();
+  if (ledger.count > 0 && now - ledger.lastAt > LOGIN_LOCK_WINDOW_MS) ledger.count = 0;
+  ledger.count += 1;
+  ledger.lastAt = now;
+}
+
+/** Antes de um login que pode falhar: se a falha seria a 3a seguida, espera o contador da identidade zerar. */
+async function waitLoginRoom(d, ledger) {
+  if (ledger.count < 2) return;
+  const gap = d.now() - ledger.lastAt;
+  if (gap <= LOGIN_LOCK_WINDOW_MS) await d.sleep(LOGIN_LOCK_WINDOW_MS - gap + 1000);
+  ledger.count = 0;
+}
+
+/** O que as credenciais gravadas conseguem: login Universal Auth e listar os segredos do projeto. */
+async function checkCreds(d, cfg, creds) {
+  const login = await d.ops.universalLogin(d.api(cfg.dominio), creds);
+  if (!login.ok) return { ok: false, motivo: login.codigo, mensagem: login.mensagem };
+  const listed = await d.ops.listSecretNames(d.api(cfg.dominio, login.accessToken), { projectId: cfg.projectId, environment: cfg.env || ENV_SLUG });
+  if (!listed.ok) {
+    // projeto apagado ou identidade tirada do projeto: a chave nao serve mais para o combinado
+    if (listed.codigo === 'nao-encontrado' || listed.codigo === 'sem-permissao') return { ok: false, motivo: 'sem-acesso', mensagem: listed.mensagem };
+    return { ok: false, motivo: listed.codigo, mensagem: listed.mensagem };
+  }
+  return { ok: true };
+}
+
+const TROCA_PENDENTE_NOTA = 'Atencao: a troca de chave deste computador ainda nao terminou — a chave antiga continua valendo. Rode de novo para terminar.';
+
+/** Troca de chave que ficou pela metade (so ids de chaves, nunca segredo) e que vale para este endereco do Infisical. */
+function readPendingRotation(cfg, dominio) {
+  const p = cfg && cfg.rotacaoPendente;
+  if (!p || typeof p !== 'object' || !Array.isArray(p.ids)) return null;
+  if (p.dominio && apiLib.normalizeDomain(p.dominio) !== dominio) return null;
+  const ids = [...new Set(p.ids.filter((x) => typeof x === 'string' && x.length > 0 && x.length <= 100))];
+  if (!ids.length) return null;
+  return { identityId: typeof p.identityId === 'string' && p.identityId ? p.identityId : null, ids };
+}
+
+/** "Nao deu para conferir a chave agora" (limite, rede, bloqueio, servidor...): NAO e prova de chave morta, entao nao cria nada. */
+function indisponivel(motivo, mensagem, nada) {
+  if (motivo === 'limite') return fim('erro', 'limite', `O Infisical limitou os acessos por enquanto (limite de uso). ${nada} Espere alguns minutos e rode de novo.`);
+  if (motivo === 'bloqueada') return fim('erro', 'bloqueada', `A chave do agente ficou bloqueada por alguns minutos (varias tentativas seguidas). ${nada} Espere uns 6 minutos e rode de novo.`);
+  if (motivo === 'rede' || motivo === 'tempo') return fim('erro', 'rede', `Sem conexao com o Infisical para conferir a chave deste computador. ${nada} Confira a internet e rode de novo.`);
+  return fim('erro', 'credencial-indisponivel', `Nao consegui conferir a chave deste computador agora (${clean(mensagem) || 'resposta inesperada do Infisical'}). ${nada} Tente de novo em alguns minutos; se continuar assim por mais de uma hora, a chave pode ter sido revogada: rode com --rotacionar.`);
+}
+
+/**
+ * Um terminal NOVO enxerga esta chave? Vale para qualquer origem. Chave que so existe no ambiente deste processo
+ * (e funciona) e gravada aqui, sem criar outra; se nao der para gravar, nao ha terminal novo que a enxergue.
+ */
+async function terminalSees(d, cand) {
+  if (await d.freshSees(cand.creds)) return true;
+  if (cand.origem === 'ambiente' && !d.envFileProblem()) {
+    try {
+      d.persistCreds(cand.creds);
+    } catch {
+      return false;
+    }
+    return Boolean(await d.freshSees(cand.creds));
+  }
+  return false;
+}
+
+function notSeenResult(origem) {
+  if (origem === 'ambiente') {
+    return fim('erro', 'nao-gravou', 'A chave funciona neste terminal, mas um terminal novo nao a enxerga e nao consegui grava-la neste computador. Peca ajuda ao Arcano com o codigo nao-gravou; nao criei nada novo.');
+  }
+  return fim('erro', 'nao-gravou', 'A chave esta gravada neste computador, mas um terminal novo nao a enxerga (o seu terminal parece ler outro arquivo de configuracao). Peca ajuda ao Arcano com o codigo nao-gravou; nao criei nada novo.');
+}
+
+/** Fecha a sessao do aluno (perfil auroq) se esta execucao a usou: o JWT de administrador da organizacao nao fica parado no computador. */
+async function closeSession(d, ctx) {
+  if (!ctx.sessionUsed || !ctx.cliPath) return;
+  let r = null;
+  try {
+    r = await d.cli.logout(ctx.cliPath);
+  } catch {
+    r = { ok: false };
+  }
+  if (r && r.ok === false) {
+    // O programa que o Auroq instalou nao esta no PATH: a linha traz o caminho dele, escrita sem sintaxe de shell
+    // (aspas e & funcionam so em alguns terminais do Windows).
+    d.out.warn(`Nao consegui sair da sua sessao do Infisical neste computador; ela expira sozinha em alguns dias. Para sair agora, rode o programa "${clean(ctx.cliPath, 400)}" com: logout --profile auroq`);
+    return;
+  }
+  d.out.log(`${DIM}O Auroq saiu da sua sessao do Infisical. Se abrir o painel do Infisical no navegador, entre de novo.${RESET}`);
+}
+
+async function connectAutomatic(opts = {}, deps = {}) {
+  const d = { ...makeDefaultDeps(), ...deps };
+  if (!d.lock.acquire()) {
+    return fim('aguardando', 'outra-execucao', 'Ja tem outra execucao do conectar-cofre (Infisical) em andamento neste computador. Espere ela terminar (ate uns 15 minutos) e rode de novo; nao abri nada em duplicidade.');
+  }
+  const prog = makeProgress(d);
+  const ctx = { cliPath: null, sessionUsed: false, trocaPendente: false, logins: newLoginLedger() };
+  let result = null;
+  let thrown = null;
+  try {
+    try {
+      result = await runConnect(opts, d, prog, ctx);
+    } catch (e) {
+      thrown = e;
+      result = fim('erro', 'falha', `Falha inesperada: ${clean(e && e.message)}`);
+    }
+    // Quando a configuracao termina (certo ou com erro que o aluno resolve em outra rodada), a sessao dele sai.
+    // Nao roda no meio de um login que ainda nao terminou (ai a sessao nem foi usada).
+    await closeSession(d, ctx);
+    if (ctx.trocaPendente && result.status !== 'ok') result = { ...result, mensagem: `${result.mensagem} ${TROCA_PENDENTE_NOTA}` };
+    prog.save(result);
+  } finally {
+    d.lock.release();
+  }
+  if (thrown) throw thrown;
+  return result;
+}
+
+async function runConnect(opts, d, prog, ctx) {
+  const out = d.out;
+  const t0 = d.now();
+  const saved = d.config.read();
+  const where = resolveDomain(opts, saved);
+  if (!where) return fim('erro', 'falha', 'Endereco do Infisical invalido. Use --regiao us, --regiao eu ou --dominio https://...');
+  const { dominio, regiao } = where;
+  if (regiao === 'custom' && !Object.values(apiLib.REGIONS).includes(dominio)) {
+    out.warn(`Usando o endereco ${dominio} (nao e o Infisical Cloud US nem EU).`);
+  }
+  let computerId = null;
+  const getComputerId = () => {
+    if (!computerId) computerId = typeof d.computerId === 'function' ? d.computerId() : localComputerId(d);
+    return computerId;
+  };
+  // Troca de chave que ficou pela metade numa rodada anterior (a chave antiga ainda vale)
+  const pending = readPendingRotation(saved, dominio);
+  if (pending) ctx.trocaPendente = true;
+
+  // 1. Ja esta conectado? (sem CLI e sem navegador: so as credenciais deste computador)
+  let reuse = null; // credencial que funciona, para nao criar outra chave
+  let reuseOrigem = null;
+  if (!opts.rotacionar) {
+    const candidates = currentCreds(d);
+    const cfg = d.config.read();
+    let dead = false;
+    if (candidates.length && cfg && cfg.projectId) {
+      for (const cand of candidates) {
+        const check = await checkCreds(d, cfg, cand.creds);
+        if (check.motivo === 'credencial-invalida') noteLoginFailure(d, ctx.logins);
+        if (check.ok) {
+          // A chave entra. Antes de dizer "conectado": um terminal novo tem de enxerga-la e ela tem de GRAVAR.
+          if (!(await terminalSees(d, cand))) return notSeenResult(cand.origem);
+          if (pending) {
+            // troca de chave incompleta: segue o fluxo so para terminar de revogar a chave antiga (sem criar outra)
+            reuse = cand.creds;
+            reuseOrigem = cand.origem;
+            dead = false;
+            break;
+          }
+          if (prog.etapas.teste !== 'feito') {
+            out.step('Testando como um terminal novo...');
+            const test = await freshTest(d, out, ctx.logins);
+            if (!test.ok) {
+              return fim('erro', 'teste-falhou', `A chave entra no projeto, mas o teste de gravar e ler um segredo falhou (${test.motivo}). Nao registrei o cofre nem disse que esta pronto. Espere um minuto e rode de novo; se continuar, confira no painel do Infisical se a identidade "${IDENTITY_NAME}" do projeto tem o papel Member (ler e gravar) e, se nao tiver, apague a identidade e rode de novo.`);
+            }
+            out.ok('Gravou, leu e apagou um segredo de teste usando so a chave do agente');
+          }
+          out.ok('Ja conectado: a chave deste computador entra no projeto Auroq.');
+          prog.all();
+          d.registerCofre('infisical');
+          return fim('ok', 'ja-conectado', 'Ja conectado: a chave do agente entra no projeto Auroq do Infisical.');
+        }
+        if (check.motivo === 'credencial-invalida' || check.motivo === 'sem-acesso') {
+          dead = true;
+          continue;
+        }
+        // Nao deu para conferir agora (limite, rede, tempo, servidor...): NAO e prova de chave morta.
+        // Criar outra chave aqui duplicaria a cada tentativa.
+        return indisponivel(check.motivo, check.mensagem, 'Nao criei nada novo, para nao duplicar.');
+      }
+      if (dead) {
+        prog.reset('identidade', 'teste', 'pronto');
+        out.warn('A chave que estava salva neste computador nao funciona mais (revogada, ou o projeto mudou). Vou gerar uma nova.');
+      }
+    } else if (candidates.length) {
+      reuse = candidates[0].creds; // ha chave mas falta a config: confere de novo mais adiante, sem criar outra
+      reuseOrigem = candidates[0].origem;
+    }
+  } else {
+    prog.reset('identidade', 'teste', 'pronto');
+  }
+
+  // Antes de criar QUALQUER coisa: a chave so aparece uma vez, entao tem de haver onde guarda-la.
+  const envProblem = d.envFileProblem();
+  if (envProblem) {
+    return fim('erro', 'arquivo-ambiente', `Nao criei nada. ${envProblem}. Peca ajuda ao Arcano com o codigo arquivo-ambiente.`);
+  }
+
+  // 2. CLI do Infisical
+  out.step('Verificando a ferramenta do Infisical (infisical)...');
+  let cli = await d.cli.find(saved && saved.cli);
+  if (!cli || cli.antigo) {
+    out.warn(cli ? `A ferramenta infisical v${cli.version} e antiga (precisa da ${cliLib.MIN_CLI_VERSION} ou mais) — instalando a nova...` : 'Ferramenta infisical nao encontrada — instalando...');
+    const inst = await d.cli.install();
+    if (!inst || !inst.ok) {
+      const detalhe = inst && inst.detalhe ? ` ${clean(inst.detalhe)}` : '';
+      if (cli) return fim('erro', 'cli-antigo', `A ferramenta infisical v${cli.version} e antiga (precisa da ${cliLib.MIN_CLI_VERSION} ou mais) e nao consegui atualizar sozinho.${detalhe}`);
+      return fim('erro', 'sem-cli', `Nao consegui instalar a ferramenta do Infisical (infisical).${detalhe}`);
+    }
+    cli = { path: inst.path, version: inst.version, antigo: false };
+  }
+  prog.mark('cli');
+  out.ok(`infisical v${cli.version}`);
+  ctx.cliPath = cli.path;
+  // Com conexao ja gravada, o endereco novo (--regiao/--dominio) so entra na config junto com a chave nova (mais
+  // abaixo): se a troca for abortada, o cofre que funcionava continua apontando para o endereco que funciona.
+  // Sem conexao gravada a config nao e usada pelo cofre (exige projectId), entao lembrar o endereco ja aqui e inofensivo.
+  const jaTemConexao = Boolean(saved && saved.projectId);
+  d.config.write(jaTemConexao ? { cli: cli.path } : { cli: cli.path, dominio, regiao });
+
+  // 3. Login no navegador (perfil proprio "auroq": nao mexe no login que o aluno ja tenha)
+  out.step('Entrando no Infisical...');
+  let status = await d.cli.loginStatus(cli.path);
+  if (status && status.state === 'authenticated' && status.domain && apiLib.normalizeDomain(status.domain) !== dominio) {
+    status = { state: 'none' }; // sessao de outra regiao/endereco: entra de novo no certo
+  }
+  if (!status || status.state !== 'authenticated') {
+    prog.reset('conta', 'login');
+    out.log(`${BOLD}Vai abrir uma pagina do Infisical no navegador. Entre na sua conta (se ainda nao tem, crie uma: e gratis) e volte aqui.${RESET}`);
+    // Espera pelo navegador: o que o aluno pediu, no maximo MAX_WAIT_SECONDS MENOS o que ja foi gasto (instalar o
+    // CLI etc.), para a execucao inteira caber nos 10 min da ferramenta do agente. Nunca 0 (seria "sem limite").
+    const spentS = Math.max(0, Math.floor((d.now() - t0) / 1000));
+    const asked = Number(opts.esperar);
+    const requested = opts.esperar !== null && opts.esperar !== undefined && Number.isFinite(asked) && asked >= 0 ? asked : DEFAULT_WAIT_SECONDS;
+    const waitSeconds = Math.max(MIN_WAIT_SECONDS, Math.min(MAX_WAIT_SECONDS - spentS, requested));
+    let loginUrl = null;
+    const login = await d.cli.browserLogin(cli.path, {
+      domain: dominio,
+      timeoutMs: waitSeconds * 1000,
+      onUrl: (url) => {
+        loginUrl = url;
+        out.log(`Se o navegador nao abrir sozinho, abra este endereco: ${url}`);
+      },
+    });
+    if (!login || !login.ok) {
+      const url = (login && login.url) || loginUrl;
+      const extra = url ? { url } : {};
+      const detalhe = login && login.detalhe ? clean(login.detalhe, 160) : '';
+      if (login && login.motivo === 'rede') return fim('erro', 'rede', `Sem conexao com o Infisical para entrar. ${detalhe}`.trim());
+      return fim('aguardando', 'login-no-navegador', `O login no navegador nao terminou${login && login.motivo === 'tempo' ? ' a tempo' : ''}. Entre na sua conta do Infisical na pagina que abriu (ou crie uma, e gratis) e rode de novo.${detalhe ? ` (${detalhe})` : ''}`, extra);
+    }
+    status = await d.cli.loginStatus(cli.path);
+    if (!status || status.state !== 'authenticated') {
+      return fim('aguardando', 'login-no-navegador', 'O login terminou mas o Infisical ainda nao confirmou a sessao. Rode de novo.');
+    }
+  }
+  // Daqui em diante existe uma sessao do aluno que ESTA execucao usa: ela sai quando a execucao termina (closeSession),
+  // seja qual for o resultado. Os erros que so se resolvem trocando de conta/organizacao tambem a encerram, para a
+  // proxima rodada abrir o navegador de novo.
+  ctx.sessionUsed = true;
+  const tok = await d.cli.getUserToken(cli.path);
+  if (!tok || !tok.ok) {
+    prog.reset('login');
+    return fim('aguardando', 'login-no-navegador', 'Nao consegui ler a sessao do Infisical neste computador. Rode de novo para entrar outra vez.');
+  }
+  const jwt = tok.token;
+  const claims = apiLib.decodeJwtPayload(jwt) || {};
+  if (claims.exp && claims.exp * 1000 < d.now() + 60000) {
+    prog.reset('login');
+    return fim('aguardando', 'login-no-navegador', 'A sessao do Infisical expirou. Rode de novo para entrar outra vez.');
+  }
+  if (!claims.organizationId) {
+    prog.reset('login');
+    return fim('erro', 'sem-organizacao', 'Sua sessao do Infisical nao tem uma organizacao escolhida. Encerrei a sessao: rode de novo e, na pagina do navegador, escolha a organizacao (ou crie uma).');
+  }
+  prog.mark('conta', 'login');
+  out.ok(`Entrou no Infisical${status.email ? ` como ${status.email}` : ''}`);
+  const userApi = d.api(dominio, jwt);
+
+  // 4. Projeto Auroq
+  out.step('Preparando o projeto Auroq...');
+  let created = false;
+  let project = await d.ops.getProjectBySlug(userApi, PROJECT_SLUG);
+  if (!project.ok && project.codigo === 'nao-encontrado') {
+    project = await d.ops.createProject(userApi, { name: PROJECT_NAME, slug: PROJECT_SLUG });
+    created = project.ok;
+  } else if (!project.ok && project.codigo === 'sem-permissao') {
+    return fim('erro', 'projeto-sem-acesso', `Ja existe um projeto com o endereco "${PROJECT_SLUG}" na sua organizacao do Infisical, mas voce nao e membro dele. Encerrei a sessao: peca acesso a quem o criou, ou rode de novo e escolha outra organizacao no navegador.`);
+  }
+  if (!project.ok) {
+    const failed = apiFail(project, 'falha-projeto', { acao: 'criar o projeto' });
+    if (failed.reentrar) prog.reset('login');
+    return failed;
+  }
+  const proj = project.project;
+  const envs = Array.isArray(proj.environments) ? proj.environments.map((e) => (e && e.slug) || e) : [];
+  if (envs.length && !envs.includes(ENV_SLUG)) {
+    return fim('erro', 'falha-projeto', `O projeto ${PROJECT_NAME} nao tem o ambiente ${ENV_SLUG} (tem: ${envs.join(', ')}). Nao mexi em nada.`);
+  }
+  out.ok(created ? `Projeto ${PROJECT_NAME} criado` : `Projeto ${PROJECT_NAME} ja existe — vou usar ele (nada do que esta nele muda).`);
+  prog.mark('projeto');
+  // O que vai para o infisical.json (endereco, projeto, identidade) so e gravado depois que a chave nova esta
+  // guardada neste computador (mais abaixo): a config e a chave andam juntas.
+  const connCfg = { dominio, regiao, orgId: claims.organizationId, projectId: proj.id, projectSlug: PROJECT_SLUG, env: ENV_SLUG, cli: cli.path, atualizado_em: new Date(d.now()).toISOString() };
+
+  // 5. Identidade do agente (identidade DO PROJETO: so enxerga este projeto) e a chave deste computador
+  out.step('Criando a chave do agente (so no projeto Auroq, sem validade)...');
+  const listed = await d.ops.listProjectIdentities(userApi, proj.id, { search: IDENTITY_NAME });
+  if (!listed.ok) {
+    const failed = apiFail(listed, 'falha-identidade', { acao: 'listar as identidades do projeto' });
+    if (failed.reentrar) prog.reset('login');
+    return failed;
+  }
+  const exact = (listed.identities || []).filter((i) => i.name === IDENTITY_NAME);
+  // A lista nao diz quais tem acesso por chave (so o GET por identidade diz): prefere a que ja tem Universal Auth.
+  let identity = null;
+  let ua = null;
+  for (const cand of exact) {
+    const found = await d.ops.getUniversalAuth(userApi, cand.id);
+    if (found.ok && found.clientId) {
+      identity = cand;
+      ua = found;
+      break;
+    }
+  }
+  if (!identity) identity = exact[0] || null;
+  const extras = exact.length > 1;
+  let novaIdentidade = false;
+  if (!identity) {
+    const createdIdentity = await d.ops.createProjectIdentity(userApi, proj.id, { name: IDENTITY_NAME, role: 'member' });
+    if (!createdIdentity.ok) {
+      const failed = apiFail(createdIdentity, 'falha-identidade', { acao: 'criar a identidade do agente' });
+      if (failed.reentrar) prog.reset('login');
+      return failed;
+    }
+    identity = createdIdentity.identity;
+    novaIdentidade = true;
+    out.ok('Identidade do agente criada');
+  } else {
+    out.ok('Identidade do agente ja existe — vou usar ela.');
+  }
+  if (identity.projectId && identity.projectId !== proj.id) {
+    return fim('erro', 'falha-identidade', 'A identidade "Auroq" encontrada nao e do projeto Auroq (alcance maior que o combinado). Nao usei; apague ou renomeie no painel do Infisical e rode de novo.');
+  }
+
+  if (!ua) {
+    const attach = await d.ops.attachUniversalAuth(userApi, identity.id, {});
+    if (!attach.ok) {
+      const failed = apiFail(attach, 'falha-identidade', { acao: 'ligar o acesso por chave a identidade' });
+      if (failed.reentrar) prog.reset('login');
+      return failed;
+    }
+    ua = attach.clientId ? attach : await d.ops.getUniversalAuth(userApi, identity.id);
+  }
+  if (!ua.ok || !ua.clientId) {
+    return apiFail(ua.ok ? { codigo: 'falha', mensagem: 'sem clientId' } : ua, 'falha-identidade', { acao: 'ler o acesso por chave da identidade' });
+  }
+  if (!isClientId(ua.clientId)) {
+    // O clientId vai para o arquivo de ambiente que o shell executa: so entra se tiver a forma de um UUID.
+    return fim('erro', 'falha-identidade', 'O Infisical devolveu o identificador da chave do agente num formato inesperado. Nao guardei nada neste computador e nao criei chave. Rode de novo; se repetir, peca ajuda ao Arcano com o codigo falha-identidade.');
+  }
+  connCfg.identityId = identity.id;
+
+  // Chaves antigas desta identidade que ainda faltam revogar (troca de chave que ficou pela metade antes)
+  let rotacaoSemAlvo = false; // --rotacionar sem achar nenhuma chave antiga para revogar (a que vazou pode continuar valendo)
+  let toRevoke = [];
+  if (pending) {
+    if (!pending.identityId || pending.identityId === identity.id) toRevoke = [...pending.ids];
+    else out.warn('Havia uma troca de chave pendente de outra identidade do Infisical; ela nao pode ser terminada por aqui.');
+  }
+
+  // Ja ha uma chave valida deste computador (so faltava a config)? Reaproveita, sem criar outra.
+  let creds = null;
+  let secretId = null;
+  if (reuse && reuse.clientId === ua.clientId) {
+    const check = await d.ops.universalLogin(d.api(dominio), reuse);
+    if (!check.ok && check.codigo === 'credencial-invalida') noteLoginFailure(d, ctx.logins);
+    if (check.ok) {
+      creds = reuse;
+      out.ok('A chave que ja estava neste computador continua valendo — nao crio outra.');
+      if (!(await terminalSees(d, { creds, origem: reuseOrigem }))) return notSeenResult(reuseOrigem);
+    } else if (check.codigo !== 'credencial-invalida') {
+      // Falha passageira (limite, rede, bloqueio, servidor...) NAO prova chave morta: criar outra deixaria a atual solta.
+      return indisponivel(check.codigo, check.mensagem, 'Nao criei chave nova, para nao deixar a atual solta.');
+    }
+  }
+  if (!creds) {
+    // Rotacao: lista ANTES as chaves antigas deste computador (a nova ainda nao existe, entao nunca entra na lista)
+    let rotationIds = [];
+    if (opts.rotacionar) {
+      const olds = await d.ops.listClientSecrets(userApi, identity.id);
+      if (!olds.ok) {
+        const failed = apiFail(olds, 'falha-chave', { acao: 'listar as chaves antigas deste computador' });
+        if (failed.reentrar) prog.reset('login');
+        if (failed.codigo === 'falha-chave') {
+          const detalhe = clean(olds.mensagem || '');
+          return fim('erro', 'falha-chave', `Nao consegui listar as chaves antigas deste computador${detalhe ? ` (${detalhe})` : ''}. Nao troquei nada: a chave atual continua valendo. Rode de novo.`);
+        }
+        return failed;
+      }
+      rotationIds = ownKeys(olds.secrets, getComputerId()).map((s) => s.id);
+      // A chave EM USO aqui e a que pode ter vazado: entra por fato, nao so pela descricao (o id do computador pode ter
+      // mudado: pasta de usuario copiada para um computador novo, sistema que nao deu o identificador numa rodada).
+      // A lista devolve os 4 primeiros caracteres de cada chave; so vale se bater com UMA chave viva. O prefixo so e
+      // comparado aqui dentro: nunca vai para tela, log nem config.
+      const vivas = (olds.secrets || []).filter((s) => !s.revoked);
+      for (const cand of currentCreds(d)) {
+        if (cand.creds.clientId !== ua.clientId) continue;
+        const achadas = vivas.filter((s) => s.prefix && s.prefix === cand.creds.clientSecret.slice(0, 4));
+        if (achadas.length === 1 && !rotationIds.includes(achadas[0].id)) rotationIds.push(achadas[0].id);
+      }
+      rotacaoSemAlvo = rotationIds.length === 0 && vivas.length > 0;
+    }
+    const description = keyDescription(d.hostname(), d.now(), getComputerId());
+    const cs = await d.ops.createClientSecret(userApi, identity.id, { description });
+    if (!cs.ok || !cs.clientSecret) {
+      const failed = apiFail(cs.ok ? { codigo: 'falha', mensagem: 'sem chave na resposta' } : cs, 'falha-chave', { acao: 'criar a chave do agente' });
+      if (failed.reentrar) prog.reset('login');
+      return failed;
+    }
+    secretId = cs.secretId;
+    creds = { clientId: ua.clientId, clientSecret: cs.clientSecret };
+    out.ok('Chave criada (nao aparece na tela)');
+    if (!isCredPair(creds)) {
+      // Nada fora do formato de uma chave do Infisical chega ao arquivo de ambiente (o shell executa o que estiver la)
+      const revoked = secretId ? await d.ops.revokeClientSecret(userApi, identity.id, secretId) : null;
+      if (revoked && revoked.ok) {
+        return fim('erro', 'falha-chave', 'O Infisical devolveu a chave num formato inesperado. Nao guardei nada neste computador e revoguei a chave. Rode de novo; se repetir, peca ajuda ao Arcano com o codigo falha-chave.');
+      }
+      return fim('erro', 'falha-chave', `O Infisical devolveu a chave num formato inesperado. Nao guardei nada neste computador, mas tambem nao consegui revogar a chave que acabei de criar: ela continua valida, sem uso. No painel do Infisical, na identidade ${IDENTITY_NAME}, apague a chave "${description}".`, { aviso: 'chave-orfa' });
+    }
+    // Daqui em diante a chave so existe aqui dentro: grava ANTES de qualquer outra coisa
+    let persistError = null;
+    try {
+      const saidaEm = d.persistCreds(creds);
+      out.ok(`Chave salva em ${saidaEm}`);
+    } catch (e) {
+      persistError = clean(e && e.message);
+    }
+    if (!persistError) {
+      const back = d.readPersistedCreds();
+      if (!back || back.clientId !== creds.clientId || back.clientSecret !== creds.clientSecret) {
+        persistError = 'um terminal novo nao enxerga o que foi gravado';
+      }
+    }
+    if (persistError) {
+      const revoked = secretId ? await d.ops.revokeClientSecret(userApi, identity.id, secretId) : null; // melhor esforco: nao deixa chave orfa
+      if (revoked && revoked.ok) {
+        return fim('erro', 'nao-gravou', `Nao consegui guardar a chave neste computador (${persistError}). Revoguei a chave que tinha acabado de criar, entao nao sobrou nada solto. Resolva isso e rode de novo.`);
+      }
+      return fim('erro', 'nao-gravou', `Nao consegui guardar a chave neste computador (${persistError.slice(0, 100)}) e tambem nao consegui revogar a que acabei de criar: ela continua valida no Infisical, sem uso. No painel, na identidade ${IDENTITY_NAME}, apague a chave "${description}". Depois resolva isso e rode de novo.`, { aviso: 'chave-orfa' });
+    }
+    // as chaves antigas deste computador viram "a revogar" (so depois do teste passar; ate la ficam lembradas na config)
+    toRevoke = [...new Set([...toRevoke, ...rotationIds.filter((id) => id !== secretId)])];
+  }
+  // A chave nova esta guardada: agora sim a config aponta para o endereco/projeto/identidade novos e lembra a troca pendente.
+  if (toRevoke.length) connCfg.rotacaoPendente = { dominio, identityId: identity.id, ids: toRevoke };
+  else if (pending) connCfg.rotacaoPendente = null; // pendencia (deste endereco) que nao se aplica mais a esta identidade
+  d.config.write(connCfg);
+  prog.mark('identidade');
+
+  // 6. Teste em terminal novo: grava, le e apaga um segredo de teste (so a chave, sem a sessao do aluno)
+  out.step('Testando como um terminal novo...');
+  const test = await freshTest(d, out, ctx.logins);
+  if (!test.ok) {
+    const troca = toRevoke.length ? ' A troca de chave ainda nao terminou: a chave antiga NAO foi revogada e continua valendo; rodar de novo termina isso.' : '';
+    return fim('erro', 'teste-falhou', `A chave foi salva mas o teste falhou (${test.motivo}). A chave nao se perde: rode de novo (sem --rotacionar) para conferir.${troca}`);
+  }
+  out.ok('Gravou, leu e apagou um segredo de teste usando so a chave do agente');
+  prog.mark('teste', 'pronto');
+
+  // 7. Fecho: so agora (com o teste passado) a chave antiga e revogada
+  let revogacao = null;
+  if (toRevoke.length) {
+    revogacao = await revokeKeys(d, userApi, identity.id, toRevoke.filter((id) => id !== secretId), out, secretId ? null : creds);
+    d.config.write({ rotacaoPendente: revogacao.restantes.length ? { dominio, identityId: identity.id, ids: revogacao.restantes } : null });
+  }
+  d.registerCofre('infisical');
+  const restart = d.platform === 'win32'
+    ? 'Feche TODAS as janelas do terminal (se usa VS Code ou Windows Terminal, feche o programa inteiro) e abra de novo, para eles enxergarem a conexao nova.'
+    : 'Feche e abra de novo o terminal (e o Claude/Codex), para eles enxergarem a conexao nova.';
+  out.log('');
+  out.ok(`${BOLD}Infisical conectado.${RESET} O agente usa so a chave: nao precisa entrar de novo no navegador.`);
+  out.log(`${DIM}${restart}${RESET}`);
+  out.log(`${DIM}Plano gratis do Infisical: 5 vagas no total (voce conta 1 e o agente Auroq, a identidade, conta 1; varias chaves da mesma identidade nao gastam vaga), projetos ilimitados e 3 ambientes. Confira os limites na tela do Infisical.${RESET}`);
+  if (extras) out.log(`${DIM}Tem mais de uma identidade chamada "${IDENTITY_NAME}" no projeto; usei a que ja tinha acesso por chave. Apague a que sobrar no painel, se quiser.${RESET}`);
+  if (revogacao && revogacao.restantes.length) {
+    const n = revogacao.restantes.length;
+    out.warn(`${n} chave(s) antiga(s) deste computador NAO foi/foram revogada(s) e continua(m) valendo.`);
+    return fim('ok', novaIdentidade ? 'criada' : 'reaproveitada', `Infisical conectado, MAS ${n} chave(s) antiga(s) deste computador AINDA NAO foi/foram revogada(s) e continua(m) valendo. Rode de novo (sem --rotacionar) para terminar a troca; se persistir, revogue a chave antiga no painel do Infisical.`, { aviso: 'revogacao-pendente' });
+  }
+  if (rotacaoSemAlvo && !(revogacao && revogacao.revogadas)) {
+    // Nao ha como saber qual era a chave antiga: dizer "ok" mudo deixaria a chave que vazou valendo sem ninguem saber.
+    out.warn('Nao achei nenhuma chave antiga deste computador para revogar: nenhuma foi revogada.');
+    return fim('ok', novaIdentidade ? 'criada' : 'reaproveitada', 'Infisical conectado e chave nova criada, MAS nao achei nenhuma chave antiga deste computador para revogar, entao NENHUMA foi revogada. Se a chave que vazou for uma antiga, ela continua valendo: apague-a no painel do Infisical (identidade Auroq, aba das chaves).', { aviso: 'chave-antiga-nao-identificada' });
+  }
+  const extra = extras ? { aviso: 'identidades-extras' } : {};
+  return fim('ok', novaIdentidade ? 'criada' : 'reaproveitada', 'Infisical conectado. A chave do agente enxerga so o projeto Auroq.', extra);
+}
+
+/**
+ * Grava, le e apaga o segredo de teste num terminal novo. Repete o login recem-criado com espera (atraso do Infisical), sem
+ * travar a chave. O nome do segredo e unico por execucao (`AUROQ_TESTE_<codigo>`): nunca pisa num segredo do aluno e dois
+ * computadores testando juntos nao se atropelam. Depois de gravar, SEMPRE tenta apagar (mesmo se a leitura falhar).
+ */
+async function freshTest(d, out, ledger = newLoginLedger()) {
+  const crypto = require('crypto');
+  const value = `teste-${crypto.randomBytes(12).toString('hex')}`;
+  const name = `${TEST_SECRET}_${crypto.randomBytes(6).toString('hex').toUpperCase()}`;
+  const codeOf = (r) => {
+    const m = String((r && r.stderr) || '').match(/AUROQ_ERRO codigo=([a-z-]+)/);
+    return m ? m[1] : null;
+  };
+  const apagar = async () => {
+    let del = null;
+    try {
+      del = await d.runFresh(['segredo', 'apagar', name, '--cofre', 'infisical', '--confirmo']);
+    } catch {
+      del = null;
+    }
+    if (!del || !del.ok) out.warn(`Nao consegui apagar o segredo de teste ${name}; pode apagar no painel do Infisical.`);
+  };
+  for (let attempt = 0; attempt <= LOGIN_RETRY_WAITS_MS.length; attempt++) {
+    await waitLoginRoom(d, ledger);
+    const wrote = await d.runFresh(['segredo', 'gravar', name, '--cofre', 'infisical'], { input: value });
+    if (wrote.ok) {
+      try {
+        const read = await d.runFresh(['segredo', 'ler', name, '--cofre', 'infisical']);
+        if (!read.ok) return { ok: false, motivo: `nao consegui ler o segredo de teste${codeOf(read) ? ` (${codeOf(read)})` : ''}` };
+        if (String(read.stdout).replace(/\r?\n$/, '') !== value) return { ok: false, motivo: 'o valor lido nao e o que foi gravado' };
+        return { ok: true };
+      } finally {
+        await apagar();
+      }
+    }
+    const code = codeOf(wrote);
+    if (code === 'credencial-invalida' && attempt < LOGIN_RETRY_WAITS_MS.length) {
+      noteLoginFailure(d, ledger);
+      await d.sleep(LOGIN_RETRY_WAITS_MS[attempt]); // atraso do Infisical logo apos criar a chave
+      continue;
+    }
+    return { ok: false, motivo: `nao consegui gravar o segredo de teste${code ? ` (${code})` : ''}` };
+  }
+  return { ok: false, motivo: 'o Infisical nao aceitou a chave nova a tempo' };
+}
+
+/**
+ * Revoga as chaves antigas (ids que ja foram marcados como DESTE computador, na hora da troca). Devolve
+ * `{ revogadas, restantes }`: so conta como revogada a que o Infisical confirmou; o que falhar fica em `restantes`
+ * para a proxima rodada. Chave que ja nao aparece (ja revogada, ou apagada) nao precisa de nada.
+ */
+async function revokeKeys(d, userApi, identityId, ids, out, emUso = null) {
+  const restantes = [];
+  let revogadas = 0;
+  const list = await d.ops.listClientSecrets(userApi, identityId);
+  const vivasLista = list.ok ? (list.secrets || []).filter((s) => !s.revoked) : null;
+  const vivas = vivasLista ? new Set(vivasLista.map((s) => s.id)) : null;
+  // `emUso`: a chave que ESTA execucao reaproveitou (nao criou uma nova). Se ela mesma esta na lista a revogar (a nova foi
+  // apagada por fora e so a antiga ainda entra), revoga-la deixaria o cofre sem nenhuma chave. Reconhece pelos 4 primeiros
+  // caracteres, so se baterem com UMA chave viva.
+  let poupada = null;
+  if (emUso && vivasLista) {
+    const achadas = vivasLista.filter((s) => s.prefix && s.prefix === emUso.clientSecret.slice(0, 4));
+    if (achadas.length === 1) poupada = achadas[0].id;
+  }
+  for (const id of ids) {
+    if (id === poupada) continue;
+    if (vivas && !vivas.has(id)) continue;
+    const r = await d.ops.revokeClientSecret(userApi, identityId, id);
+    if (r && r.ok) revogadas += 1;
+    else if (!(r && r.codigo === 'nao-encontrado')) restantes.push(id);
+  }
+  if (revogadas) out.ok(`${revogadas} chave(s) antiga(s) deste computador revogada(s)`);
+  return { revogadas, restantes };
+}
+
+// ─── Estado (onde o aluno esta), sem falar com o Infisical ────────────────
+
+async function describeState(d) {
+  const saved = d.state.read();
+  const etapas = saved ? { ...saved.etapas } : emptyEtapas();
+  const cfg = d.config.read();
+  const cli = await d.cli.find(cfg && cfg.cli); // so roda `infisical --version`, local
+  etapas.cli = cli && !cli.antigo ? 'feito' : 'pendente';
+  const hasCreds = currentCreds(d).length > 0;
+  const hasConfig = Boolean(cfg && cfg.projectId);
+  if (!hasCreds || !hasConfig) {
+    // chave apagada, computador novo ou config perdida: o que dependia dela volta a ficar pendente
+    for (const e of ['identidade', 'teste', 'pronto']) etapas[e] = 'pendente';
+  } else if (!saved) {
+    etapas.identidade = 'feito'; // ha chave e config (outra execucao ou migracao); ainda nao provada
+  }
+  if (etapas.identidade !== 'feito' || etapas.teste !== 'feito') etapas.pronto = 'pendente';
+  const feitas = ETAPAS.filter((e) => etapas[e] === 'feito');
+  const proxima = nextStage(etapas);
+  const resumo = !proxima ? 'pronto' : (feitas.length || saved ? 'em-andamento' : 'nao-iniciado');
+  return {
+    resumo,
+    proxima,
+    feitas,
+    etapas,
+    credencial: hasCreds ? 'configurado' : 'ausente',
+    ultimo: saved && saved.ultimo ? saved.ultimo.codigo : null,
+    atualizado_em: saved ? saved.atualizado_em : null,
+  };
+}
+
+function buildStateLine(st) {
+  return `AUROQ_ESTADO infisical=${st.resumo} proxima=${st.proxima || 'nenhuma'} feitas=${st.feitas.join(',') || 'nenhuma'} credencial=${st.credencial} ultimo=${st.ultimo || 'nenhum'} conferido=nao`;
+}
+
+/** Linha que o Ops le (mesmo padrao da rota A). */
+function buildResultLine(result) {
+  // 800: cabe a pior mensagem (limite-plano com o detalhe de 300) + TROCA_PENDENTE_NOTA sem cortar a nota do fim
+  const msg = clean(result.mensagem, 800).replace(/"/g, "'");
+  const aviso = result.aviso ? ` aviso=${result.aviso}` : '';
+  const url = result.url ? ` url="${clean(result.url, 300).replace(/"/g, "'")}"` : '';
+  return `AUROQ_RESULTADO infisical=${result.status} codigo=${result.codigo}${aviso}${url} mensagem="${msg}"`;
+}
+
+function showState(st) {
+  console.log(`\n${PURPLE}${BOLD}  Infisical — onde voce esta${RESET}`);
+  for (const e of ETAPAS.filter((x) => x !== 'pronto')) {
+    const feito = st.etapas[e] === 'feito';
+    console.log(`  ${feito ? `${GREEN}✓${RESET}` : `${GOLD}·${RESET}`} ${ETAPA_NOME[e]}`);
+  }
+  log('');
+  if (st.resumo === 'pronto') log(`${GREEN}${BOLD}Tudo pronto.${RESET} ${DIM}(Nao conferi com o Infisical agora: rode sem --estado para provar.)${RESET}`);
+  else log(`Proxima etapa: ${BOLD}${ETAPA_NOME[st.proxima]}${RESET}. Rode ${CYAN}npx auroq-os conectar-cofre --cofre infisical${RESET} para continuar de onde parou.`);
+  log('');
+}
+
+// Erros que o aluno (ou o plano dele) resolve: saem com 1, mas a telemetria nao os conta como instalacao quebrada.
+const STUDENT_ACTIONABLE = new Set(['sem-cli', 'cli-antigo', 'rede', 'login-no-navegador', 'sem-permissao', 'limite-plano', 'projeto-sem-acesso', 'credencial-indisponivel', 'arquivo-ambiente', 'sem-organizacao', 'bloqueada', 'limite', 'plano-restringe']);
+
+function isStudentActionable(codigo) {
+  return STUDENT_ACTIONABLE.has(codigo);
+}
+
+// ─── Entrada do comando ──────────────────────────────────
+
+/**
+ * `auroq-os conectar-cofre --cofre infisical [--agente] [--estado] [--rotacionar] [--regiao us|eu] [--dominio URL] [--esperar N]`
+ * Codigo de saida: 0 conectado OU falta uma acao do aluno (entrar no navegador: a linha AUROQ_RESULTADO diz
+ * qual), 1 erro.
+ */
+async function connect(options = {}) {
+  const opts = options.argv ? parseArgs(options.argv) : { ...parseArgs([]), ...options };
+  if (opts.estado) {
+    const st = await describeState({ ...makeDefaultDeps(), ...(options.deps || {}) });
+    if (opts.agente) console.log(buildStateLine(st));
+    else showState(st);
+    return st;
+  }
+  if (!opts.agente) console.log(`\n${PURPLE}${BOLD}  Conectar Infisical (cofre gratis) — Auroq OS${RESET}`);
+  let result;
+  try {
+    result = await connectAutomatic(opts, options.deps || {});
+  } catch (e) {
+    result = fim('erro', 'falha', `Falha inesperada: ${clean(e && e.message)}`);
+  }
+  if (result.status === 'aguardando') warn(result.mensagem);
+  else if (result.status === 'erro') err(result.mensagem);
+  if (opts.agente) console.log(buildResultLine(result));
+  process.exitCode = EXIT_CODE[result.status] ?? 1;
+  return result;
+}
+
+module.exports = {
+  connect,
+  connectAutomatic,
+  describeState,
+  buildStateLine,
+  buildResultLine,
+  parseArgs,
+  resolveDomain,
+  isStudentActionable,
+  // credenciais no computador
+  persistCreds,
+  readPersistedCreds,
+  envFileProblem,
+  upsertEnvFileContent,
+  parseEnvFileCreds,
+  hasDynamicCredDefinition,
+  // arquivos e estado
+  readConfig,
+  writeConfig,
+  configFile,
+  readState,
+  writeState,
+  stateFile,
+  nextStage,
+  keyMarker,
+  keyDescription,
+  hostLabel,
+  ownKeys,
+  machineSeed,
+  localComputerId,
+  makeDefaultDeps,
+  runInFreshShell,
+  ETAPAS,
+  ETAPA_NOME,
+  CLIENT_ID_VAR,
+  CLIENT_SECRET_VAR,
+  PROJECT_NAME,
+  PROJECT_SLUG,
+  IDENTITY_NAME,
+  ENV_SLUG,
+  TEST_SECRET,
+};