auroq-os 2.8.0 → 2.8.2

package/lib/infisical-cli.js

@@ -0,0 +1,869 @@
+'use strict';
+
+/**
+ * Auroq OS — Rota B (Infisical gratis): tudo que toca o binario `infisical`.
+ *
+ * Achar o programa e a versao, instalar sem admin, ver se ha sessao, entrar pelo navegador, ler o token
+ * da sessao do aluno e sair. Nenhuma funcao daqui cria conta, projeto ou identidade (isso e da API, em
+ * lib/infisical-api.js).
+ *
+ * Regras que valem para o arquivo inteiro:
+ *  - Nenhum segredo (JWT da sessao, client secret) vai para tela, log, mensagem de erro ou argumento de
+ *    comando. O JWT so volta no retorno de `getUserToken`; qualquer texto do CLI que va para `detalhe`
+ *    passa por `scrub` (apaga JWT, 64 hex, st.- e ops_-tokens).
+ *  - Nenhum passo usa sudo/admin, e nenhum edita o PATH do aluno (nem o do processo): o chamador guarda o
+ *    CAMINHO ABSOLUTO do binario.
+ *  - O filho nunca herda INFISICAL_* / TOKEN do aluno (viram credencial do CLI e mudam a sessao) nem as
+ *    variaveis AUROQ_INFISICAL_* (a chave do agente: o CLI nao precisa dela).
+ *  - Tudo que fala com o mundo entra por `d` (deps): `run`, `download`, `fs`, `exists`, `platform`, `arch`, `env`, `tmpdir`.
+ *    Os testes so usam falsos; `makeDefaultCliDeps()` traz os reais. Forma de cada um:
+ *      run(file, args, { env, input, timeoutMs, stdinIgnore, onStderr }) -> Promise<{ ok, status, stdout, stderr, timedOut, missing }>
+ *      download(url) -> Promise<Buffer> (lanca se falhar; `error.status` quando for resposta HTTP)
+ *      fs: mkdtempSync, mkdirSync, writeFileSync, copyFileSync, chmodSync, renameSync, rmSync, readdirSync, existsSync
+ *  - Funcoes com rede/processo sao `async` (o `run` padrao e assincrono). Nenhuma lanca por falha do CLI.
+ *
+ * Fatos de comportamento do binario: pesquisa/resultado-cli.md e resultado-instalacao.md.
+ *
+ * @module auroq-os/infisical-cli
+ */
+
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const fs = require('fs');
+const { spawn, spawnSync } = require('child_process');
+
+// Versao minima aceita: login por navegador SEM terminal + perfis (--profile/--save-as) so existem a partir daqui
+// (resultado-cli.md, secao 7: "Login por navegador seguro sem TTY: v0.43.139"). O projeto e criado pela API,
+// entao o `sm projects create` (0.44.3) nao e necessario.
+const MIN_CLI_VERSION = '0.43.139';
+// Versao que o instalador direto baixa. Fixa de proposito ("latest" muda todo dia e a API do GitHub tem limite baixo).
+const PINNED_CLI_VERSION = '0.44.8';
+// Perfil proprio do Auroq no CLI: nao mexe no login que o aluno ja tenha para o trabalho dele.
+const PROFILE = 'auroq';
+const DEFAULT_DOMAIN = 'https://app.infisical.com';
+
+const RELEASE_BASE = 'https://github.com/Infisical/cli/releases/download';
+const VERSION_TIMEOUT_MS = 30000; // primeira execucao de um binario de 160 MB pode demorar
+const STATUS_TIMEOUT_MS = 30000;
+const TOKEN_TIMEOUT_MS = 30000;
+const LOGOUT_TIMEOUT_MS = 60000;
+const EXTRACT_TIMEOUT_MS = 300000;
+const INSTALL_TIMEOUT_MS = 15 * 60 * 1000;
+const DEFAULT_LOGIN_TIMEOUT_MS = 540000;
+const DOWNLOAD_TIMEOUT_MS = 15 * 60 * 1000;
+const DOWNLOAD_MAX_BYTES = 400 * 1024 * 1024;
+const OUTPUT_CAP = 16 * 1024 * 1024;
+const SCRUB_MAX_INPUT = 2000;
+
+// ─── Helpers puros ───────────────────────────────────────
+
+const pathFor = (platform) => (platform === 'win32' ? path.win32 : path.posix);
+
+/** Le variavel de ambiente sem ligar para maiusculas (no Windows `Path` e `PATH` sao a mesma). */
+function envGet(env, name) {
+  if (!env) return undefined;
+  if (env[name] !== undefined) return env[name];
+  const low = name.toLowerCase();
+  for (const k of Object.keys(env)) {
+    if (k.toLowerCase() === low) return env[k];
+  }
+  return undefined;
+}
+
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+const stripAnsi = (text) => String(text == null ? '' : text).replace(ANSI_RE, '');
+
+/**
+ * Apaga de um texto o que parece segredo (JWT, client secret de 64 hex, token st. e ops_), junta em uma linha
+ * e limita o tamanho. Tudo o que o CLI disser e vai para `detalhe` passa por aqui.
+ */
+function scrub(text, max = 300) {
+  // Corta ANTES das regex: as de 'token' custam N^2 em texto longo e o stderr do CLI pode ter megabytes.
+  // O resultado final tem `max` caracteres, entao o que passa de SCRUB_MAX_INPUT nunca apareceria mesmo.
+  let t = stripAnsi(String(text == null ? '' : text).slice(0, SCRUB_MAX_INPUT * 4)).replace(/\s+/g, ' ').trim().slice(0, SCRUB_MAX_INPUT);
+  t = t.replace(/\beyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]*/g, '[oculto]');
+  t = t.replace(/\b[A-Za-z0-9_-]{12,}\.[A-Za-z0-9_-]{12,}\.[A-Za-z0-9_-]{12,}\b/g, '[oculto]');
+  t = t.replace(/\b[0-9a-fA-F]{64}\b/g, '[oculto]');
+  t = t.replace(/\bst\.[A-Za-z0-9._-]{10,}/g, '[oculto]');
+  t = t.replace(/\bops_[A-Za-z0-9_=+/.-]{10,}/g, '[oculto]');
+  t = t.replace(/\s+/g, ' ').trim();
+  return t.length > max ? `${t.slice(0, max - 3)}...` : t;
+}
+
+/** Ultima linha util do stderr (preferindo a que fala de erro), ja sem segredo. */
+function lastErrorLine(stderr, max = 200) {
+  const lines = stripAnsi(stderr).split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  if (!lines.length) return '';
+  const hit = [...lines].reverse().find((l) => /(error|failed|unable|denied|not found|does not exist|timeout|refused|no such host)/i.test(l));
+  return scrub(hit || lines[lines.length - 1], max);
+}
+
+const NET_RE = /(no such host|dial tcp|connection refused|connection reset|network is unreachable|i\/o timeout|tls handshake|enotfound|econnrefused|econnreset|eai_again|unable to complete api request|temporary failure in name resolution)/i;
+
+function validProfile(profile) {
+  return typeof profile === 'string' && /^[A-Za-z0-9][A-Za-z0-9._-]{0,39}$/.test(profile);
+}
+
+function validDomain(domain) {
+  return typeof domain === 'string' && /^https?:\/\/[^\s"'<>]+$/i.test(domain);
+}
+
+/**
+ * Ambiente do `infisical` filho. Tira INFISICAL_* e TOKEN (o CLI le INFISICAL_TOKEN/TOKEN como credencial
+ * e eles passam por cima da sessao do perfil `auroq`) e as variaveis da chave do agente; liga a
+ * desativacao do aviso de atualizacao (senao cada comando espera ate ~16 s pelo GitHub). Tira tambem as
+ * variaveis OP_* (token do 1Password): cada rota so enxerga a sua credencial.
+ */
+function cliEnv(base) {
+  const src = base || process.env;
+  const env = {};
+  for (const [k, v] of Object.entries(src)) {
+    if (v === undefined || v === null) continue;
+    // OP_*: a credencial da outra rota (1Password) nao tem por que chegar ao infisical, curl, tar, brew ou winget
+    if (/^(AUROQ_)?INFISICAL_/i.test(k) || /^TOKEN$/i.test(k) || /^OP_/i.test(k)) continue;
+    env[k] = v;
+  }
+  env.INFISICAL_DISABLE_UPDATE_CHECK = '1';
+  return env;
+}
+
+/** `infisical --version` imprime `infisical version 0.44.8`. Build local imprime `devel` e lixo vira null. */
+function parseCliVersion(stdout) {
+  const m = /^infisical version (\d+\.\d+\.\d+)/m.exec(stripAnsi(stdout));
+  return m ? m[1] : null;
+}
+
+function splitVersion(v) {
+  if (typeof v !== 'string') return null;
+  const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+
+/** Comparacao numerica (0.43.1000 > 0.43.139). Versao ilegivel nunca passa. */
+function isCliVersionAtLeast(version, min = MIN_CLI_VERSION) {
+  const a = splitVersion(version);
+  const b = splitVersion(min);
+  if (!a || !b) return false;
+  for (let i = 0; i < 3; i++) {
+    if (a[i] > b[i]) return true;
+    if (a[i] < b[i]) return false;
+  }
+  return true;
+}
+
+/** Pastas onde o `infisical` costuma ficar quando o PATH do terminal nao o enxerga. */
+function knownCliDirs(platform, env) {
+  const P = pathFor(platform);
+  const e = env || process.env;
+  const dirs = [];
+  const add = (...parts) => {
+    if (parts.every(Boolean)) dirs.push(P.join(...parts));
+  };
+  if (platform === 'win32') {
+    const local = envGet(e, 'LOCALAPPDATA');
+    const profile = envGet(e, 'USERPROFILE');
+    const appData = envGet(e, 'APPDATA');
+    add(local, 'Programs', 'infisical');
+    add(local, 'Microsoft', 'WinGet', 'Links');
+    add(profile, 'scoop', 'shims');
+    add(profile, '.local', 'bin');
+    add(appData, 'npm', 'node_modules', '@infisical', 'cli', 'bin');
+    return dirs;
+  }
+  const home = envGet(e, 'HOME') || os.homedir();
+  add(home, '.local', 'bin');
+  if (platform === 'darwin') {
+    dirs.push('/opt/homebrew/bin', '/usr/local/bin');
+  } else {
+    dirs.push('/usr/local/bin', '/usr/bin');
+  }
+  return dirs;
+}
+
+const binName = (platform) => (platform === 'win32' ? 'infisical.exe' : 'infisical');
+
+/** Pastas do PATH (so as absolutas: pasta vazia/relativa significaria "a pasta atual"). */
+function pathDirs(platform, env) {
+  const P = pathFor(platform);
+  const raw = envGet(env, 'PATH') || '';
+  return String(raw)
+    .split(platform === 'win32' ? ';' : ':')
+    .map((s) => s.trim().replace(/^"(.*)"$/, '$1'))
+    .filter((s) => s && P.isAbsolute(s));
+}
+
+// ─── Dependencias reais (trocaveis nos testes) ───────────
+
+/**
+ * Roda um programa sem shell. Nunca lanca. A saida pode ter segredo: quem chama decide o que mostrar.
+ * Opcoes: env, input (stdin), stdinIgnore (stdin = /dev/null: sem terminal, o que faz o CLI esperar o
+ * navegador), timeoutMs (mata o processo), onStdout/onStderr (pedacos em tempo real), cwd.
+ * Devolve `{ ok, status, stdout, stderr, timedOut, missing }`.
+ */
+function runProcess(file, args, opts = {}) {
+  const { env, input, timeoutMs = 120000, stdinIgnore = false, cwd, onStdout, onStderr } = opts;
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(file, args || [], {
+        env: env || process.env,
+        cwd,
+        stdio: [stdinIgnore ? 'ignore' : 'pipe', 'pipe', 'pipe'],
+        windowsHide: true,
+      });
+    } catch (e) {
+      resolve({ ok: false, status: null, stdout: '', stderr: String((e && e.message) || e), timedOut: false, missing: Boolean(e && e.code === 'ENOENT') });
+      return;
+    }
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    let error = null;
+    let status = null;
+    let done = false;
+    let killTimer = null;
+    let graceTimer = null;
+    let timer = null;
+
+    const finish = () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      clearTimeout(killTimer);
+      clearTimeout(graceTimer);
+      if (error && !stderr) stderr = String(error.message || error); // ex.: EACCES (arquivo sem permissao de execucao)
+      try { child.stdout.destroy(); } catch { /* ja fechado */ }
+      try { child.stderr.destroy(); } catch { /* ja fechado */ }
+      resolve({
+        ok: !error && !timedOut && status === 0,
+        status,
+        stdout,
+        stderr,
+        timedOut,
+        missing: Boolean(error && error.code === 'ENOENT'),
+      });
+    };
+
+    const feed = (which, cb) => (chunk) => {
+      if (which === 'out') { if (stdout.length < OUTPUT_CAP) stdout += chunk; } else if (stderr.length < OUTPUT_CAP) stderr += chunk;
+      if (typeof cb === 'function') {
+        try { cb(chunk); } catch { /* callback do chamador nunca derruba o processo */ }
+      }
+    };
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', feed('out', onStdout));
+    child.stderr.on('data', feed('err', onStderr));
+
+    if (!stdinIgnore && child.stdin) {
+      child.stdin.on('error', () => {}); // o filho pode fechar antes de ler tudo (EPIPE)
+      child.stdin.end(input === undefined || input === null ? '' : String(input));
+    }
+
+    if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        try { child.kill('SIGTERM'); } catch { /* ja morreu */ }
+        killTimer = setTimeout(() => {
+          try { child.kill('SIGKILL'); } catch { /* ja morreu */ }
+        }, 2000);
+      }, timeoutMs);
+    }
+
+    child.on('error', (e) => { error = e; finish(); });
+    child.on('exit', (code) => {
+      status = code;
+      // Um neto (ex.: o login que o CLI dispara sozinho) pode segurar os canais abertos: nao espera por ele.
+      graceTimer = setTimeout(finish, 1500);
+    });
+    child.on('close', (code) => {
+      if (status === null) status = code;
+      finish();
+    });
+  });
+}
+
+/** Baixa por `curl` (respeita o proxy do sistema, que o fetch do Node ignora). Lanca se falhar. */
+function curlDownload(url, platform, spawn = spawnSync) {
+  const curl = platform === 'darwin' ? '/usr/bin/curl' : (platform === 'win32' ? 'curl.exe' : 'curl');
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'auroq-dl-'));
+  const file = path.join(dir, 'arquivo');
+  try {
+    const r = spawn(curl, ['-fL', '--silent', '--show-error', '--connect-timeout', '30', '--max-time', '900', '-o', file, url], {
+      env: cliEnv(process.env), // o curl nao precisa da chave do agente nem da credencial do 1Password; o proxy do sistema continua valendo
+      stdio: ['ignore', 'ignore', 'pipe'],
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: 16 * 60 * 1000,
+    });
+    if (r.error || r.status !== 0) {
+      const e = new Error(`curl falhou (${r.error ? r.error.code || r.error.message : `saida ${r.status}`})`);
+      e.curl = true;
+      throw e;
+    }
+    return fs.readFileSync(file);
+  } finally {
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* fica no temp do sistema */ }
+  }
+}
+
+/** Baixa um arquivo inteiro para a memoria. `fetch` primeiro; reserva: `curl -fL`. 404 nao tenta de novo. Lanca se falhar. */
+async function defaultDownload(url, platform = process.platform) {
+  let first = null;
+  if (typeof fetch === 'function') {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), DOWNLOAD_TIMEOUT_MS);
+    try {
+      const res = await fetch(url, { redirect: 'follow', signal: ctrl.signal, headers: { 'User-Agent': 'auroq-os' } });
+      if (!res.ok) {
+        const e = new Error(`HTTP ${res.status}`);
+        e.status = res.status;
+        throw e;
+      }
+      const len = Number(res.headers.get('content-length'));
+      if (Number.isFinite(len) && len > DOWNLOAD_MAX_BYTES) throw new Error('arquivo grande demais');
+      const buf = Buffer.from(await res.arrayBuffer());
+      if (buf.length > DOWNLOAD_MAX_BYTES) throw new Error('arquivo grande demais');
+      return buf;
+    } catch (e) {
+      if (e && e.status === 404) throw e; // a release ainda nao tem o arquivo (acontece nos primeiros ~35 min): curl nao muda isso
+      first = e;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  try {
+    return curlDownload(url, platform);
+  } catch (e) {
+    if (first && first.status) { e.status = first.status; }
+    throw e;
+  }
+}
+
+function makeDefaultCliDeps(overrides = {}) {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    env: process.env,
+    fs,
+    exists: (p) => fs.existsSync(p),
+    tmpdir: os.tmpdir(),
+    run: runProcess,
+    download: (url) => defaultDownload(url, process.platform),
+    ...overrides,
+  };
+}
+
+/** Completa o `d` recebido com os padroes reais (os testes passam so o que querem trocar). */
+function withDefaults(d) {
+  const base = makeDefaultCliDeps();
+  const out = { ...base };
+  for (const [k, v] of Object.entries(d || {})) {
+    if (v !== undefined) out[k] = v;
+  }
+  if (!(d && d.exists) && d && d.fs) out.exists = (p) => d.fs.existsSync(p);
+  return out;
+}
+
+// ─── Achar o CLI e a versao ──────────────────────────────
+
+/** Roda `<arquivo> --version`. Devolve a versao ou null (nao rodou, saiu com erro, saida vazia = binario falso, `devel`). */
+async function probeVersion(d, file) {
+  let r;
+  try {
+    r = await d.run(file, ['--version'], { env: cliEnv(d.env), timeoutMs: VERSION_TIMEOUT_MS, stdinIgnore: true });
+  } catch {
+    return null;
+  }
+  if (!r || !r.ok || r.timedOut) return null;
+  return parseCliVersion(r.stdout);
+}
+
+/**
+ * Acha o `infisical`: primeiro o caminho gravado (`preferred`), depois o PATH, depois as pastas conhecidas.
+ * Cada candidato roda `--version` pelo caminho ABSOLUTO. Devolve `{ path, version, antigo, via }` do primeiro
+ * com versao valida e >= MIN; se so houver velhos, devolve o primeiro deles com `antigo: true`; senao null.
+ * Saida vazia com exit 0 (atalho falso do npm no Git Bash) e `devel` sao ignorados.
+ */
+async function findCli(dIn, { preferred } = {}) {
+  const d = withDefaults(dIn);
+  const P = pathFor(d.platform);
+  const seen = new Set();
+  const candidates = [];
+  const add = (file, via) => {
+    if (!file || typeof file !== 'string') return;
+    const key = d.platform === 'win32' ? file.toLowerCase() : file;
+    if (seen.has(key)) return;
+    seen.add(key);
+    candidates.push({ file, via });
+  };
+  add(preferred, 'gravado');
+  for (const dir of pathDirs(d.platform, d.env)) add(P.join(dir, binName(d.platform)), 'path');
+  for (const dir of knownCliDirs(d.platform, d.env)) add(P.join(dir, binName(d.platform)), 'conhecido');
+
+  let antigo = null;
+  for (const c of candidates) {
+    let exists = false;
+    try { exists = Boolean(d.exists(c.file)); } catch { exists = false; }
+    if (!exists) continue;
+    const version = await probeVersion(d, c.file);
+    if (!version) continue;
+    if (isCliVersionAtLeast(version, MIN_CLI_VERSION)) return { path: c.file, version, antigo: false, via: c.via };
+    if (!antigo) antigo = { path: c.file, version, antigo: true, via: c.via };
+  }
+  return antigo;
+}
+
+// ─── Instalar o CLI (sem admin, sem mexer no PATH) ───────
+
+/** Nome do arquivo, URLs e binario da release pinada para este sistema, ou null se nao houver. */
+function releaseTarget(platform, arch, version = PINNED_CLI_VERSION) {
+  const osName = platform === 'darwin' ? 'darwin' : (platform === 'win32' ? 'windows' : null);
+  const archName = arch === 'arm64' ? 'arm64' : (arch === 'x64' ? 'amd64' : null);
+  if (!osName || !archName) return null;
+  const ext = platform === 'darwin' ? 'tar.gz' : 'zip';
+  const file = `cli_${version}_${osName}_${archName}.${ext}`;
+  const base = `${RELEASE_BASE}/v${version}`;
+  return {
+    file,
+    url: `${base}/${file}`,
+    checksumsFile: platform === 'darwin' ? 'checksums-darwin.txt' : 'checksums.txt',
+    checksumsUrl: `${base}/${platform === 'darwin' ? 'checksums-darwin.txt' : 'checksums.txt'}`,
+    binary: binName(platform),
+  };
+}
+
+/** `checksums*.txt` do goreleaser: uma linha `<sha256>  <arquivo>` por arquivo. */
+function parseChecksums(text) {
+  const map = new Map();
+  for (const line of String(text == null ? '' : text).split(/\r?\n/)) {
+    const m = /^([0-9a-fA-F]{64})\s+\*?(\S+)\s*$/.exec(line.trim());
+    if (m) map.set(m[2].replace(/^\.\//, ''), m[1].toLowerCase());
+  }
+  return map;
+}
+
+function toBuffer(x) {
+  return Buffer.isBuffer(x) ? x : Buffer.from(x == null ? '' : x);
+}
+
+function downloadFailure(what, e) {
+  const status = e && Number.isFinite(e.status) ? e.status : null;
+  if (status) return { ok: false, motivo: 'falhou', detalhe: `${what}: o servidor respondeu ${status}` };
+  return { ok: false, motivo: 'sem-rede', detalhe: `${what}: nao consegui baixar (${scrub((e && e.message) || 'sem resposta', 120)})` };
+}
+
+function homeFor(d) {
+  const P = pathFor(d.platform);
+  const env = d.env || {};
+  const h = d.platform === 'win32' ? (envGet(env, 'USERPROFILE') || envGet(env, 'HOME')) : envGet(env, 'HOME');
+  return h && P.isAbsolute(h) ? h : os.homedir();
+}
+
+function localAppDataFor(d) {
+  const P = pathFor(d.platform);
+  const env = d.env || {};
+  const l = envGet(env, 'LOCALAPPDATA');
+  if (l) return l;
+  const u = envGet(env, 'USERPROFILE');
+  return u ? P.join(u, 'AppData', 'Local') : null;
+}
+
+/** Passo 1: binario direto da release pinada, com SHA-256 conferido, em pasta do usuario. */
+async function installDirect(d) {
+  const P = pathFor(d.platform);
+  const t = releaseTarget(d.platform, d.arch);
+  if (!t) return { ok: false, motivo: 'plataforma', detalhe: `nao ha binario direto para ${d.platform}/${d.arch}` };
+
+  let destDir;
+  if (d.platform === 'darwin') {
+    destDir = P.join(homeFor(d), '.local', 'bin');
+  } else {
+    const local = localAppDataFor(d);
+    if (!local) return { ok: false, motivo: 'falhou', detalhe: 'nao achei a pasta LOCALAPPDATA' };
+    destDir = P.join(local, 'Programs', 'infisical');
+  }
+  const dest = P.join(destDir, t.binary);
+
+  // 1) checksums da MESMA release (pequeno): se faltar, nem baixa o arquivo grande
+  let sums;
+  try {
+    sums = toBuffer(await d.download(t.checksumsUrl)).toString('utf8');
+  } catch (e) {
+    return downloadFailure('checksums', e);
+  }
+  const expected = parseChecksums(sums).get(t.file);
+  if (!expected) return { ok: false, motivo: 'sha256', detalhe: `o arquivo de checksums nao traz ${t.file}` };
+
+  // 2) arquivo: confere ANTES de gravar qualquer coisa
+  let archive;
+  try {
+    archive = toBuffer(await d.download(t.url));
+  } catch (e) {
+    return downloadFailure(t.file, e);
+  }
+  const actual = crypto.createHash('sha256').update(archive).digest('hex');
+  if (actual !== expected) {
+    return { ok: false, motivo: 'sha256', detalhe: `SHA-256 de ${t.file} diferente do publicado (${actual.slice(0, 12)} em vez de ${expected.slice(0, 12)}); nada foi instalado` };
+  }
+
+  // 3) extrai so o binario para uma pasta temporaria propria, copia para o destino por temporario + rename
+  const f = d.fs;
+  let tmp = null;
+  let placed = null;
+  const existedBefore = (() => { try { return Boolean(d.exists(dest)); } catch { return false; } })();
+  try {
+    tmp = f.mkdtempSync(P.join(d.tmpdir || os.tmpdir(), 'auroq-infisical-'));
+    const archivePath = P.join(tmp, t.file);
+    const outDir = P.join(tmp, 'out');
+    f.mkdirSync(outDir, { recursive: true });
+    f.writeFileSync(archivePath, archive, { mode: 0o600 });
+
+    const env = cliEnv(d.env);
+    const extracted = P.join(outDir, t.binary);
+    if (d.platform === 'darwin') {
+      const r = await d.run('/usr/bin/tar', ['-xzf', archivePath, '-C', outDir, t.binary], { env, timeoutMs: EXTRACT_TIMEOUT_MS, stdinIgnore: true });
+      if (!r || !r.ok) return { ok: false, motivo: 'falhou', detalhe: `tar nao conseguiu abrir o arquivo (${lastErrorLine(r && r.stderr) || 'sem detalhe'})` };
+    } else {
+      const sysRoot = envGet(d.env, 'SystemRoot') || envGet(d.env, 'windir');
+      const tarExe = sysRoot ? P.join(sysRoot, 'System32', 'tar.exe') : 'tar.exe'; // o do Windows (bsdtar); o do Git nao le zip
+      let r = await d.run(tarExe, ['-xf', archivePath, '-C', outDir, t.binary], { env, timeoutMs: EXTRACT_TIMEOUT_MS, stdinIgnore: true });
+      let ok = Boolean(r && r.ok) && Boolean(d.exists(extracted));
+      if (!ok) {
+        const ps = sysRoot ? P.join(sysRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe') : 'powershell.exe';
+        // caminhos por variavel de ambiente: nada de aspas nem de nome de usuario com apostrofo dentro do comando
+        r = await d.run(ps, [
+          '-NoProfile', '-NonInteractive', '-Command',
+          "$ProgressPreference='SilentlyContinue'; Expand-Archive -LiteralPath $env:AUROQ_ZIP -DestinationPath $env:AUROQ_OUT -Force",
+        ], { env: { ...env, AUROQ_ZIP: archivePath, AUROQ_OUT: outDir }, timeoutMs: EXTRACT_TIMEOUT_MS, stdinIgnore: true });
+        ok = Boolean(r && r.ok);
+      }
+      if (!ok) return { ok: false, motivo: 'falhou', detalhe: `nao consegui abrir o zip (${lastErrorLine(r && r.stderr) || 'sem detalhe'})` };
+    }
+    if (!d.exists(extracted)) return { ok: false, motivo: 'falhou', detalhe: `${t.binary} nao estava dentro de ${t.file}` };
+
+    f.mkdirSync(destDir, { recursive: true });
+    placed = P.join(destDir, `.${t.binary}.auroq-${process.pid}-${crypto.randomBytes(3).toString('hex')}.tmp`);
+    f.copyFileSync(extracted, placed);
+    f.chmodSync(placed, 0o755);
+    f.renameSync(placed, dest);
+    placed = null;
+    if (d.platform === 'darwin') {
+      // melhor esforco: arquivo baixado por curl/Node nao costuma ter quarentena, mas o Gatekeeper nao deve barrar
+      await d.run('/usr/bin/xattr', ['-d', 'com.apple.quarantine', dest], { env, timeoutMs: 30000, stdinIgnore: true });
+    }
+  } catch (e) {
+    return { ok: false, motivo: 'falhou', detalhe: `nao consegui gravar em ${destDir} (${scrub((e && e.message) || 'erro', 120)})` };
+  } finally {
+    if (placed) { try { f.rmSync(placed, { force: true }); } catch { /* sobra so um arquivo oculto */ } }
+    if (tmp) { try { f.rmSync(tmp, { recursive: true, force: true }); } catch { /* fica no temp do sistema */ } }
+  }
+
+  const version = await probeVersion(d, dest);
+  if (!version || !isCliVersionAtLeast(version, MIN_CLI_VERSION)) {
+    if (!existedBefore) { try { f.rmSync(dest, { force: true }); } catch { /* sem problema */ } }
+    return { ok: false, motivo: 'falhou', detalhe: version ? `o infisical instalado diz ser a versao ${version} (minima ${MIN_CLI_VERSION})` : 'o infisical instalado nao respondeu a --version (o sistema pode ter bloqueado o programa)' };
+  }
+  return { ok: true, path: dest, version };
+}
+
+function findBrew(d) {
+  const P = pathFor(d.platform);
+  const list = ['/opt/homebrew/bin/brew', '/usr/local/bin/brew'];
+  for (const dir of pathDirs(d.platform, d.env)) list.push(P.join(dir, 'brew'));
+  for (const file of list) {
+    try { if (d.exists(file)) return file; } catch { /* proximo */ }
+  }
+  return null;
+}
+
+/** Passo 2 (Mac): Homebrew, so se ele ja existir (nunca instala o brew: isso pede senha de admin). Nome qualificado SEMPRE. */
+async function installBrew(d) {
+  const P = pathFor(d.platform);
+  const brew = findBrew(d);
+  if (!brew) return { ok: false, motivo: 'falhou', detalhe: 'brew nao encontrado (nao instalo o Homebrew)' };
+  const env = { ...cliEnv(d.env), HOMEBREW_NO_AUTO_UPDATE: '1', HOMEBREW_NO_ENV_HINTS: '1' };
+  const r = await d.run(brew, ['install', 'infisical/get-cli/infisical'], { env, timeoutMs: INSTALL_TIMEOUT_MS, stdinIgnore: true });
+  const check = async (file) => {
+    let exists = false;
+    try { exists = Boolean(d.exists(file)); } catch { exists = false; }
+    if (!exists) return null;
+    const version = await probeVersion(d, file);
+    return version && isCliVersionAtLeast(version, MIN_CLI_VERSION) ? { ok: true, path: file, version } : null;
+  };
+  // o brew liga o programa na mesma pasta do proprio `brew` (/opt/homebrew/bin ou /usr/local/bin)
+  let found = await check(P.join(P.dirname(brew), 'infisical'));
+  if (!found && r && r.ok) {
+    const q = await d.run(brew, ['--prefix'], { env, timeoutMs: 30000, stdinIgnore: true });
+    const prefix = q && q.ok ? String(q.stdout).trim().split(/\r?\n/)[0] : '';
+    if (prefix && P.isAbsolute(prefix)) found = await check(P.join(prefix, 'bin', 'infisical'));
+  }
+  if (found) return found;
+  if (!r || !r.ok) return { ok: false, motivo: 'falhou', detalhe: `brew install falhou (${(r && r.timedOut) ? 'demorou demais' : (lastErrorLine(r && r.stderr) || 'sem detalhe')})` };
+  return { ok: false, motivo: 'falhou', detalhe: 'o brew terminou mas o infisical nao respondeu a --version' };
+}
+
+/** Passo 2 (Windows): winget, escopo do usuario, sem perguntas. Pode entregar versao um pouco antiga: conferida contra o minimo. */
+async function installWinget(d) {
+  const P = pathFor(d.platform);
+  const env = cliEnv(d.env);
+  const probe = await d.run('winget', ['--version'], { env, timeoutMs: 30000, stdinIgnore: true });
+  if (!probe || !probe.ok) return { ok: false, motivo: 'falhou', detalhe: 'winget nao encontrado' };
+  const r = await d.run('winget', [
+    'install', '--id', 'infisical.infisical', '-e', '--source', 'winget', '--scope', 'user',
+    '--accept-package-agreements', '--accept-source-agreements', '--disable-interactivity',
+  ], { env, timeoutMs: INSTALL_TIMEOUT_MS, stdinIgnore: true });
+
+  // Sem Modo Desenvolvedor o winget nao cria o atalho em Links: o programa fica na pasta do pacote.
+  const candidates = [];
+  const local = localAppDataFor(d);
+  if (local) {
+    candidates.push(P.join(local, 'Microsoft', 'WinGet', 'Links', 'infisical.exe'));
+    const pkgs = P.join(local, 'Microsoft', 'WinGet', 'Packages');
+    try {
+      for (const name of d.fs.readdirSync(pkgs)) {
+        if (/^infisical\.infisical/i.test(String(name))) candidates.push(P.join(pkgs, String(name), 'infisical.exe'));
+      }
+    } catch { /* pasta ainda nao existe */ }
+  }
+  for (const file of candidates) {
+    let exists = false;
+    try { exists = Boolean(d.exists(file)); } catch { exists = false; }
+    if (!exists) continue;
+    const version = await probeVersion(d, file);
+    if (version && isCliVersionAtLeast(version, MIN_CLI_VERSION)) return { ok: true, path: file, version };
+  }
+  if (!r || !r.ok) return { ok: false, motivo: 'falhou', detalhe: `winget install falhou (${(r && r.timedOut) ? 'demorou demais' : (lastErrorLine(r && r.stderr) || `saida ${r && r.status}`)})` };
+  return { ok: false, motivo: 'falhou', detalhe: 'o winget terminou mas nao achei um infisical que responda a --version' };
+}
+
+/**
+ * Instala o `infisical` sem admin. Ordem: (1) binario direto pinado, com SHA-256; (2) Mac: `brew install
+ * infisical/get-cli/infisical` (so se o brew ja existe); Windows: winget. Cada passo confere `--version` pelo
+ * caminho absoluto. Nenhum passo usa sudo nem mexe no PATH. Devolve `{ ok:true, path, version, via }` ou
+ * `{ ok:false, motivo:'sem-rede'|'sha256'|'plataforma'|'falhou', detalhe }` (o motivo e o do primeiro passo que falhou).
+ */
+async function installCli(dIn) {
+  const d = withDefaults(dIn);
+  if (d.platform !== 'darwin' && d.platform !== 'win32') {
+    return { ok: false, motivo: 'plataforma', detalhe: `instalacao automatica so no macOS e no Windows (aqui: ${d.platform})` };
+  }
+  const falhas = [];
+  const steps = [['direto', installDirect], [d.platform === 'darwin' ? 'brew' : 'winget', d.platform === 'darwin' ? installBrew : installWinget]];
+  for (const [via, fn] of steps) {
+    let r;
+    try {
+      r = await fn(d);
+    } catch (e) {
+      r = { ok: false, motivo: 'falhou', detalhe: scrub((e && e.message) || 'erro inesperado', 120) };
+    }
+    if (r.ok) return { ok: true, path: r.path, version: r.version, via };
+    falhas.push({ via, motivo: r.motivo, detalhe: r.detalhe });
+  }
+  return {
+    ok: false,
+    motivo: falhas[0].motivo,
+    detalhe: falhas.map((f) => `${f.via}: ${f.detalhe}`).join(' | '),
+  };
+}
+
+// ─── Sessao do aluno ─────────────────────────────────────
+
+function parseJsonObject(text) {
+  const t = String(text == null ? '' : text).trim();
+  try {
+    const v = JSON.parse(t);
+    return v && typeof v === 'object' ? v : null;
+  } catch {
+    const a = t.indexOf('{');
+    const b = t.lastIndexOf('}');
+    if (a !== -1 && b > a) {
+      try { return JSON.parse(t.slice(a, b + 1)); } catch { /* ilegivel */ }
+    }
+    return null;
+  }
+}
+
+const emptyStatus = (state, extra = {}) => ({ state, email: null, organizationName: null, domain: null, exp: null, ...extra });
+
+/**
+ * Ha sessao no perfil? `<cli> login status --json --profile auroq` (nao dispara login, nao grava nada).
+ *  - authenticated: exit 0 e status authenticated (offline = verification "unknown" tambem entra, com `offline:true`)
+ *  - expired: venceu (exit 1) ou o servidor recusou ("rejected")
+ *  - none: sem sessao (`{"sessions":[]}`) ou perfil inexistente
+ *  - unknown: saida ilegivel, tempo esgotado, keyring ilegivel
+ * Devolve `{ state, email, organizationName, domain, exp }` (exp em segundos unix, ou null).
+ */
+async function loginStatus(dIn, cli, { profile = PROFILE } = {}) {
+  const d = withDefaults(dIn);
+  if (!cli || typeof cli !== 'string' || !validProfile(profile)) return emptyStatus('unknown', { detalhe: 'caminho do CLI ou perfil invalido' });
+  let r;
+  try {
+    r = await d.run(cli, ['login', 'status', '--json', '--profile', profile], { env: cliEnv(d.env), timeoutMs: STATUS_TIMEOUT_MS, stdinIgnore: true });
+  } catch {
+    return emptyStatus('unknown', { detalhe: 'nao consegui rodar o CLI' });
+  }
+  if (!r) return emptyStatus('unknown', { detalhe: 'sem resposta do CLI' });
+  if (r.timedOut) return emptyStatus('unknown', { detalhe: 'o CLI demorou demais' });
+  if (r.missing) return emptyStatus('unknown', { detalhe: 'CLI nao encontrado' });
+
+  const doc = parseJsonObject(r.stdout);
+  if (doc && Array.isArray(doc.sessions)) {
+    if (!doc.sessions.length) return emptyStatus('none');
+    const s = doc.sessions.find((x) => x && x.principalType === 'user') || doc.sessions[0];
+    if (!s || typeof s !== 'object') return emptyStatus('unknown', { detalhe: 'sessao ilegivel' });
+    const info = {
+      email: typeof s.email === 'string' ? s.email : null,
+      organizationName: typeof s.organizationName === 'string' ? s.organizationName : null,
+      domain: typeof s.domain === 'string' ? s.domain : null,
+      exp: s.token && Number.isFinite(Number(s.token.exp)) && Number(s.token.exp) > 0 ? Number(s.token.exp) : null,
+    };
+    if (s.status === 'authenticated') {
+      if (!r.ok) return { state: 'unknown', ...info, detalhe: 'o CLI disse autenticado mas saiu com erro' };
+      const offline = Boolean(s.verification && s.verification.state === 'unknown');
+      return { state: 'authenticated', ...info, offline };
+    }
+    if (s.status === 'expired') return { state: 'expired', ...info };
+    if (s.status === 'rejected') return { state: 'expired', ...info, rejeitada: true };
+    return { state: 'unknown', ...info, detalhe: `situacao desconhecida (${scrub(s.status, 40)})` };
+  }
+
+  // Sem JSON. Perfil que nao existe na configuracao: o CLI avisa no stderr e sai com 1 (sem sessao, na pratica).
+  const err = stripAnsi(r.stderr);
+  if (!r.ok && /(does not exist|ErrProfileNotFound|no login profiles|not authenticated)/i.test(`${err}\n${stripAnsi(r.stdout)}`)) return emptyStatus('none');
+  return emptyStatus('unknown', { detalhe: lastErrorLine(r.stderr) || 'saida ilegivel do CLI' });
+}
+
+/**
+ * Acha, num texto do stderr, o endereco do login (`.../login?callback_port=NNNN`). Com `complete` falso so
+ * vale URL seguida de espaco ou quebra de linha (o texto pode ainda estar chegando).
+ */
+function extractLoginUrl(text, { complete = false } = {}) {
+  const clean = stripAnsi(text);
+  const re = /https?:\/\/[^\s"'<>]+/g;
+  let m;
+  while ((m = re.exec(clean)) !== null) {
+    if (!complete && m.index + m[0].length >= clean.length) break;
+    const url = m[0].replace(/[.,;:!?)\]]+$/, '');
+    const before = clean.slice(clean.lastIndexOf('\n', m.index) + 1, m.index);
+    if (/callback_port=/.test(url) || /\/login(\?|\/|$)/.test(url) || /(browser|address|endereco)/i.test(before)) return url;
+  }
+  return null;
+}
+
+/**
+ * Login do aluno no navegador: `<cli> login --domain <dominio> --save-as auroq --silent`, com stdin IGNORADO
+ * (sem terminal o CLI so espera o navegador, sem perguntar nada). Le o stderr em tempo real, chama
+ * `onUrl(url)` UMA vez com o endereco do login e mata o processo ao estourar `timeoutMs`.
+ * NUNCA usa `--plain` (imprimiria o JWT da sessao). Devolve `{ ok:true, url }` (exit 0) ou
+ * `{ ok:false, motivo:'tempo'|'rede'|'falhou', url, detalhe }`.
+ */
+async function browserLogin(dIn, cli, { domain, profile = PROFILE, timeoutMs = DEFAULT_LOGIN_TIMEOUT_MS, onUrl } = {}) {
+  const d = withDefaults(dIn);
+  if (!cli || typeof cli !== 'string') return { ok: false, motivo: 'falhou', url: null, detalhe: 'caminho do CLI ausente' };
+  if (!validProfile(profile)) return { ok: false, motivo: 'falhou', url: null, detalhe: 'nome de perfil invalido' };
+  // Sem --domain o CLI pergunta a regiao (menu) e sem terminal isso trava ou falha: nunca roda sem.
+  if (!validDomain(domain)) return { ok: false, motivo: 'falhou', url: null, detalhe: 'dominio do Infisical ausente ou invalido' };
+
+  let url = null;
+  let buffer = '';
+  const found = (candidate) => {
+    if (url || !candidate) return;
+    url = candidate;
+    if (typeof onUrl === 'function') {
+      try {
+        const r = onUrl(candidate);
+        if (r && typeof r.then === 'function') r.then(null, () => {});
+      } catch { /* quem mostra a URL nao derruba o login */ }
+    }
+  };
+  const onStderr = (chunk) => {
+    if (url) return;
+    buffer = (buffer + chunk).slice(-65536);
+    found(extractLoginUrl(buffer));
+  };
+
+  let r;
+  try {
+    r = await d.run(cli, ['login', '--domain', domain, '--save-as', profile, '--silent'], {
+      env: cliEnv(d.env), timeoutMs, stdinIgnore: true, onStderr,
+    });
+  } catch {
+    return { ok: false, motivo: 'falhou', url, detalhe: 'nao consegui rodar o CLI' };
+  }
+  r = r || {};
+  // `run` sem tempo real (ou saida que chegou toda no fim): olha o texto final
+  if (!url) found(extractLoginUrl(`${buffer}\n${r.stderr || ''}\n`, { complete: true }));
+
+  if (r.timedOut) return { ok: false, motivo: 'tempo', url, detalhe: 'o login no navegador nao terminou a tempo' };
+  if (r.missing) return { ok: false, motivo: 'falhou', url, detalhe: 'CLI nao encontrado' };
+  if (r.ok) return { ok: true, url };
+  const err = lastErrorLine(r.stderr) || `o CLI saiu com codigo ${r.status}`;
+  return { ok: false, motivo: NET_RE.test(stripAnsi(r.stderr)) ? 'rede' : 'falhou', url, detalhe: err };
+}
+
+// JWT: tres partes base64url; o cabecalho de um JWT sempre comeca com eyJ (base64 de `{"`). Evita confundir com "0.44.8".
+const JWT_RE = /^eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+
+/**
+ * JWT da sessao do aluno (`<cli> user get token --plain --profile auroq`). So chamar DEPOIS de `loginStatus` =
+ * authenticated: com a sessao vencida o CLI dispararia um login por conta propria. O token so existe no retorno:
+ * nunca vai para tela, log nem mensagem de erro. Devolve `{ ok:true, token }` ou `{ ok:false, motivo, detalhe }`.
+ */
+async function getUserToken(dIn, cli, { profile = PROFILE } = {}) {
+  const d = withDefaults(dIn);
+  if (!cli || typeof cli !== 'string' || !validProfile(profile)) return { ok: false, motivo: 'falhou', detalhe: 'caminho do CLI ou perfil invalido' };
+  let r;
+  try {
+    r = await d.run(cli, ['user', 'get', 'token', '--plain', '--profile', profile], { env: cliEnv(d.env), timeoutMs: TOKEN_TIMEOUT_MS, stdinIgnore: true });
+  } catch {
+    return { ok: false, motivo: 'falhou', detalhe: 'nao consegui rodar o CLI' };
+  }
+  if (!r) return { ok: false, motivo: 'falhou', detalhe: 'sem resposta do CLI' };
+  if (r.timedOut) return { ok: false, motivo: 'tempo', detalhe: 'o CLI demorou demais' };
+  if (r.missing) return { ok: false, motivo: 'falhou', detalhe: 'CLI nao encontrado' };
+  // Em caso de erro so o stderr entra na mensagem (o stdout e onde o token apareceria).
+  if (!r.ok) return { ok: false, motivo: 'falhou', detalhe: lastErrorLine(r.stderr) || `o CLI saiu com codigo ${r.status}` };
+  const token = stripAnsi(r.stdout).split(/\r?\n/).map((l) => l.trim()).find((l) => JWT_RE.test(l));
+  if (!token) return { ok: false, motivo: 'falhou', detalhe: 'a saida do CLI nao tem a forma de um token de sessao' };
+  return { ok: true, token };
+}
+
+/** Sai do perfil (`<cli> logout --profile auroq`). Melhor esforco: nunca lanca. Devolve `{ ok, detalhe? }`. */
+async function logoutProfile(dIn, cli, { profile = PROFILE } = {}) {
+  try {
+    const d = withDefaults(dIn);
+    if (!cli || typeof cli !== 'string' || !validProfile(profile)) return { ok: false, detalhe: 'caminho do CLI ou perfil invalido' };
+    const r = await d.run(cli, ['logout', '--profile', profile], { env: cliEnv(d.env), timeoutMs: LOGOUT_TIMEOUT_MS, stdinIgnore: true });
+    if (r && r.ok) return { ok: true };
+    return { ok: false, detalhe: (r && r.timedOut) ? 'o CLI demorou demais' : (lastErrorLine(r && r.stderr) || 'o CLI nao conseguiu sair do perfil') };
+  } catch {
+    return { ok: false, detalhe: 'erro ao rodar o CLI' };
+  }
+}
+
+module.exports = {
+  MIN_CLI_VERSION,
+  PINNED_CLI_VERSION,
+  PROFILE,
+  DEFAULT_DOMAIN,
+  parseCliVersion,
+  isCliVersionAtLeast,
+  knownCliDirs,
+  findCli,
+  installCli,
+  loginStatus,
+  browserLogin,
+  getUserToken,
+  logoutProfile,
+  cliEnv,
+  // alem do contrato: dependencias reais e pecas puras que os testes e o orquestrador usam
+  makeDefaultCliDeps,
+  runProcess,
+  curlDownload,
+  extractLoginUrl,
+  releaseTarget,
+  parseChecksums,
+  scrub,
+};