auroq-os 2.8.0 → 2.8.2

package/lib/infisical-api.js

@@ -0,0 +1,670 @@
+'use strict';
+
+/**
+ * Auroq OS - Cliente da API do Infisical (rota B, cofre gratis)
+ *
+ * So fala HTTP: sem estado, sem disco, sem CLI. Quem orquestra (lib/infisical.js) injeta o dominio, o token
+ * e, nos testes, o `fetch` e o `sleep`. Contrato em saida/desenho.md (secao 3); rotas e corpos conferidos
+ * contra pesquisa/resultado-api.md (e o codigo do backend citado la).
+ *
+ * Regras que valem para tudo aqui:
+ *  - `client.request` NUNCA lanca: devolve `{ ok:true, status, data }` ou `{ ok:false, status, codigo, mensagem }`.
+ *  - Nenhum segredo (JWT, client secret, token de acesso, `st.`/`ops_`) sai em `mensagem`: passa por `redact`
+ *    e o proprio token do cliente e apagado por valor exato. O corpo bruto da resposta nunca e devolvido.
+ *  - O client secret so existe na resposta de `createClientSecret` e no corpo do login. Nunca em URL/argumento.
+ *
+ * Assinatura das operacoes: `op(client, ...)`. A forma principal e posicional, como no desenho
+ * (`getProjectBySlug(client, 'auroq')`, `listProjectIdentities(client, projectId, { search })`);
+ * tambem aceita um objeto unico (`getProjectBySlug(client, { slug })`, `listProjectIdentities(client, { projectId, search })`).
+ *
+ * @module auroq-os/infisical-api
+ */
+
+const REGIONS = Object.freeze({
+  us: 'https://app.infisical.com',
+  eu: 'https://eu.infisical.com',
+});
+
+const MASK = '[oculto]';
+const HIDDEN_VALUE = '<hidden-by-infisical>';
+const MAX_MESSAGE = 300;
+// Texto do servidor que entra no redact: o redact tem regex que custam N^2 em texto longo, e um servidor
+// hostil (--dominio) poderia mandar uma mensagem gigante. Como a mensagem final tem MAX_MESSAGE, o resto nunca aparece.
+const MAX_SCAN = 2000;
+const REDACT_MAX_INPUT = 8000;
+const BACKOFF_MS = [500, 1500];
+const MAX_RETRY_AFTER_S = 15;
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '[::1]']);
+
+// ─── Helpers puros ───────────────────────────────────────
+
+/**
+ * Normaliza o dominio do Infisical: `us`/`eu` viram a regiao; URL https (ou http so em loopback, para
+ * teste) perde o `/api` e a `/` do final. Devolve `null` se for invalido.
+ */
+function normalizeDomain(input) {
+  if (typeof input !== 'string') return null;
+  const text = input.trim();
+  if (!text) return null;
+  const regiao = text.toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(REGIONS, regiao)) return REGIONS[regiao];
+  let url;
+  try {
+    url = new URL(text);
+  } catch {
+    return null;
+  }
+  if (url.username || url.password || url.search || url.hash || !url.hostname) return null;
+  if (url.protocol === 'http:') {
+    if (!LOOPBACK_HOSTS.has(url.hostname)) return null;
+  } else if (url.protocol !== 'https:') {
+    return null;
+  }
+  const caminho = url.pathname.replace(/\/+$/, '').replace(/\/api$/i, '').replace(/\/+$/, '');
+  return url.origin + caminho;
+}
+
+const JWT_SHAPE_RE = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+const BASE64URL_RE = /^[A-Za-z0-9_-]+$/;
+
+/** Tres partes base64url separadas por ponto. Nao prova que e um token valido. */
+function isJwtShape(value) {
+  return typeof value === 'string' && JWT_SHAPE_RE.test(value.trim());
+}
+
+/** Client secret do Universal Auth: 64 caracteres hexadecimais minusculos. */
+function isClientSecretShape(value) {
+  return typeof value === 'string' && /^[0-9a-f]{64}$/.test(value);
+}
+
+/** Le o payload do JWT (base64url, SEM verificar assinatura). Objeto ou `null`; nunca lanca. */
+function decodeJwtPayload(jwt) {
+  try {
+    if (!isJwtShape(jwt)) return null;
+    const meio = jwt.trim().split('.')[1].replace(/=+$/, '');
+    if (!BASE64URL_RE.test(meio)) return null;
+    const payload = JSON.parse(Buffer.from(meio, 'base64url').toString('utf8'));
+    return payload && typeof payload === 'object' && !Array.isArray(payload) ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+const REDACT_RULES = [
+  [/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, `Bearer ${MASK}`],
+  [/eyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}(?:\.[A-Za-z0-9_-]*)?/g, MASK],
+  [/[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, MASK],
+  [/(?<![0-9A-Za-z])[0-9a-fA-F]{64}(?![0-9A-Za-z])/g, MASK],
+  [/\bst\.[A-Za-z0-9._-]{8,}/g, MASK],
+  [/\bops_[A-Za-z0-9_=+/.-]{20,}/g, MASK],
+];
+
+/**
+ * Apaga JWTs, client secrets (64 hex), tokens `st.`/`ops_` e `Bearer ...` de um texto. As regex custam N^2 em
+ * texto longo (um servidor hostil poderia travar o programa com uma mensagem gigante), entao so os primeiros
+ * REDACT_MAX_INPUT caracteres entram: o resto e descartado, nunca devolvido sem limpar.
+ */
+function redact(text) {
+  let out = String(text === undefined || text === null ? '' : text).slice(0, REDACT_MAX_INPUT);
+  for (const [re, troca] of REDACT_RULES) out = out.replace(re, troca);
+  return out;
+}
+
+function oneLine(text) {
+  return String(text).replace(/\s+/g, ' ').trim();
+}
+
+function issueText(issue) {
+  if (typeof issue === 'string') return issue;
+  if (!issue || typeof issue.message !== 'string') return '';
+  const caminho = Array.isArray(issue.path) && issue.path.length ? `${issue.path.join('.')}: ` : '';
+  return caminho + issue.message;
+}
+
+/** Texto do `message` da API (string, ou lista de problemas do zod no 422). */
+function messageOf(body) {
+  if (body === undefined || body === null) return '';
+  if (typeof body === 'string') return body;
+  if (typeof body !== 'object') return '';
+  if (typeof body.message === 'string') return body.message;
+  if (Array.isArray(body.message)) return body.message.map(issueText).filter(Boolean).join('; ');
+  if (typeof body.detail === 'string') return body.detail;
+  return '';
+}
+
+// 400 do plano: so o limite de VAGAS (identidades/membros, que dividem as 5 vagas do Free) vira 'limite-plano'.
+// Qualquer outra recusa do plano (papel, faixa de IP, ambientes, projetos) vira 'plano-restringe': o aluno nao
+// resolve apagando identidade, e a mensagem nao pode mandar fazer isso.
+const RE_PLAN_ANY = /limit reached|plan limit|plan (?:\w+ )?restriction|rbac|custom role|upgrade (?:your )?plan|upgrade to /i;
+const RE_PLAN_SEATS = /\b(?:identity|identities|member|members|user|users)\b[^.]{0,40}\blimit\b|\blimit\b[^.]{0,40}\b(?:identity|identities|members?|users?)\b/i;
+const RE_EXISTS = /already exists|already a member|already configured/i;
+const RE_SESSION = /re-?authenticate|log in again|no longer valid|no organization found|has been revoked/i;
+
+/**
+ * Traduz status HTTP + corpo da API em um `codigo` fixo:
+ * rede/tempo (fetch lancou) sao decididos em `request`; aqui so o que veio de resposta.
+ */
+function classifyHttp(status, body) {
+  const code = Number(status);
+  const message = messageOf(body);
+  const error = body && typeof body === 'object' && typeof body.error === 'string' ? body.error : '';
+  const tokenError = error === 'TokenError' || error === 'InvalidToken';
+  if (!code) return 'rede';
+  if (code === 429) return 'limite';
+  if (code >= 500) return 'servidor';
+  if (code === 401) {
+    if (/invalid credentials/i.test(message)) return 'credencial-invalida';
+    if (/temporarily locked/i.test(message)) return 'bloqueada';
+    // 'no organization found' vem no campo `error` (o `message` fica 'You are not allowed to access this resource')
+    if (tokenError || RE_SESSION.test(message) || RE_SESSION.test(error)) return 'sessao-expirada';
+    return 'falha';
+  }
+  if (code === 403) return tokenError ? 'sessao-expirada' : 'sem-permissao';
+  if (code === 400) {
+    if (RE_PLAN_SEATS.test(message)) return 'limite-plano';
+    if (RE_PLAN_ANY.test(message)) return 'plano-restringe';
+    if (RE_EXISTS.test(message)) return 'ja-existe';
+    return 'falha';
+  }
+  if (code === 404) return 'nao-encontrado';
+  if (code === 422) return 'invalido';
+  return 'falha';
+}
+
+// ─── Cliente HTTP ────────────────────────────────────────
+
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function positive(value, fallback) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+function queryString(query) {
+  if (!query || typeof query !== 'object') return '';
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined || value === null) continue;
+    params.append(key, String(value));
+  }
+  const text = params.toString();
+  return text ? `?${text}` : '';
+}
+
+function retryAfterOf(res, message) {
+  try {
+    const header = res && res.headers && typeof res.headers.get === 'function' ? res.headers.get('retry-after') : null;
+    if (header !== null && header !== undefined && /^\d+(?:\.\d+)?$/.test(String(header).trim())) return Number(header);
+  } catch {
+    // sem header: tenta a mensagem
+  }
+  const m = /try again in (\d+(?:\.\d+)?) seconds?/i.exec(message || '');
+  return m ? Number(m[1]) : undefined;
+}
+
+function networkHint(err) {
+  const code = err && ((err.cause && err.cause.code) || err.code);
+  return typeof code === 'string' && /^[A-Z0-9_]{3,40}$/.test(code) ? ` (${code})` : '';
+}
+
+/**
+ * Cria o cliente HTTP. `baseUrl` e o dominio SEM `/api` (use `normalizeDomain`); as operacoes montam `/api/...`.
+ * `token` vai em `Authorization: Bearer` (a menos que a chamada peca `auth: 'none'`, como o login).
+ */
+function createClient(options = {}) {
+  const o = options && typeof options === 'object' ? options : {};
+  const baseUrl = typeof o.baseUrl === 'string' ? o.baseUrl.trim().replace(/\/+$/, '') : '';
+  const token = typeof o.token === 'string' && o.token ? o.token : null;
+  const fetchImpl = typeof o.fetchImpl === 'function' ? o.fetchImpl : globalThis.fetch;
+  const userAgent = typeof o.userAgent === 'string' && o.userAgent ? o.userAgent : 'auroq-os';
+  const sleep = typeof o.sleep === 'function' ? o.sleep : defaultSleep;
+  const defaultTimeout = positive(o.timeoutMs, 20000);
+  const maxRetries = typeof o.maxRetries === 'number' && o.maxRetries >= 0 ? Math.floor(o.maxRetries) : 2;
+
+  async function pause(ms) {
+    try {
+      await sleep(ms);
+    } catch {
+      // um sleep injetado que falha nao pode derrubar a chamada
+    }
+  }
+
+  async function request(method, path, opts) {
+    try {
+      return await run(method, path, opts && typeof opts === 'object' ? opts : {});
+    } catch {
+      return { ok: false, status: 0, codigo: 'falha', mensagem: 'erro interno no cliente da API' };
+    }
+  }
+
+  async function run(method, path, opts) {
+    const verb = String(method || 'GET').toUpperCase();
+    const falha = (codigo, mensagem) => ({ ok: false, status: 0, codigo, mensagem });
+    if (!/^[A-Z]{3,7}$/.test(verb)) return falha('falha', 'metodo HTTP invalido');
+    if (typeof path !== 'string' || !path.startsWith('/')) return falha('falha', 'caminho da API invalido');
+    if (!/^https?:\/\/[^/\s]+/i.test(baseUrl)) return falha('falha', 'dominio do Infisical invalido');
+    if (typeof fetchImpl !== 'function') return falha('rede', 'esta versao do Node nao tem fetch (use Node 18 ou mais novo)');
+
+    const url = baseUrl + path + queryString(opts.query);
+    const headers = { Accept: 'application/json', 'User-Agent': userAgent };
+    if (opts.auth !== 'none' && token) headers.Authorization = `Bearer ${token}`;
+    let payload;
+    if (opts.body !== undefined && opts.body !== null) {
+      payload = JSON.stringify(opts.body);
+      headers['Content-Type'] = 'application/json';
+    }
+    const timeoutMs = positive(opts.timeoutMs, defaultTimeout);
+
+    // valores exatos que nunca podem aparecer em mensagem (alem dos padroes do redact)
+    const literais = [token, opts.body && opts.body.clientSecret, opts.body && opts.body.secretValue].filter(
+      (v) => typeof v === 'string' && v.length >= 8,
+    );
+    const limpar = (text) => {
+      let out = String(text);
+      // 1) valores exatos no texto INTEIRO (split/join e linear; o corte abaixo nao pode deixar parte do segredo de fora)
+      for (const literal of literais) out = out.split(literal).join(MASK);
+      // 2) corta ANTES do redact (regex quadratica em texto longo)
+      out = oneLine(out).slice(0, MAX_SCAN);
+      return oneLine(redact(out)).slice(0, MAX_MESSAGE);
+    };
+
+    async function once() {
+      const controller = new AbortController();
+      let timedOut = false;
+      let timer;
+      const limite = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          timedOut = true;
+          controller.abort();
+          reject(new Error('tempo'));
+        }, timeoutMs);
+      });
+      const trabalho = (async () => {
+        const res = await fetchImpl(url, { method: verb, headers, body: payload, signal: controller.signal, redirect: 'error' });
+        const text = await res.text();
+        return { res, text };
+      })();
+      trabalho.catch(() => {});
+      let got;
+      try {
+        got = await Promise.race([trabalho, limite]);
+      } catch (err) {
+        if (timedOut) return { ok: false, status: 0, codigo: 'tempo', mensagem: 'o Infisical nao respondeu a tempo' };
+        return { ok: false, status: 0, codigo: 'rede', mensagem: `sem conexao com o Infisical${networkHint(err)}` };
+      } finally {
+        clearTimeout(timer);
+      }
+
+      const status = Number(got.res && got.res.status) || 0;
+      let parsed = null;
+      let isJson = false;
+      const text = typeof got.text === 'string' ? got.text : '';
+      if (text.trim()) {
+        try {
+          parsed = JSON.parse(text);
+          isJson = true;
+        } catch {
+          parsed = null;
+        }
+      }
+      if (status >= 200 && status < 300) {
+        if (!text.trim()) return { ok: true, status, data: {} };
+        if (!isJson) return { ok: false, status, codigo: 'falha', mensagem: 'a resposta do Infisical nao veio em JSON' };
+        return { ok: true, status, data: parsed };
+      }
+      const body = parsed && typeof parsed === 'object' ? parsed : null;
+      const bruto = messageOf(body);
+      const out = {
+        ok: false,
+        status,
+        codigo: classifyHttp(status, body),
+        mensagem: limpar(bruto) || `HTTP ${status}`,
+      };
+      const depois = status === 429 ? retryAfterOf(got.res, bruto) : undefined;
+      if (depois !== undefined) out.retryAfter = depois;
+      return out;
+    }
+
+    // Repetir 5xx/erro de rede so e seguro quando repetir nao duplica nada: leituras (GET) e as chamadas que
+    // a operacao marca com `repetir: true` (login e revogacao). POST de criacao (projeto, identidade, client
+    // secret) NUNCA repete: o servidor pode ter gravado antes de o gateway devolver o erro. O 429 repete sempre,
+    // porque a requisicao foi recusada antes de ser processada.
+    const podeRepetir5xx = opts.repetir === true || verb === 'GET' || verb === 'HEAD';
+    let tentativas5xx = 0;
+    let usou429 = false;
+    for (;;) {
+      const r = await once();
+      if (r.ok) return r;
+      if ((r.codigo === 'servidor' || r.codigo === 'rede') && podeRepetir5xx && tentativas5xx < maxRetries) {
+        await pause(BACKOFF_MS[Math.min(tentativas5xx, BACKOFF_MS.length - 1)]);
+        tentativas5xx += 1;
+        continue;
+      }
+      if (r.codigo === 'limite' && !usou429 && typeof r.retryAfter === 'number' && r.retryAfter <= MAX_RETRY_AFTER_S) {
+        usou429 = true;
+        await pause(Math.ceil(r.retryAfter * 1000) + 500);
+        continue;
+      }
+      return r;
+    }
+  }
+
+  return { request };
+}
+
+// ─── Operacoes ───────────────────────────────────────────
+
+const enc = encodeURIComponent;
+
+function opFail(r) {
+  const out = { ok: false, codigo: r.codigo || 'falha', mensagem: r.mensagem || '' };
+  if (r.status !== undefined) out.status = r.status;
+  if (r.retryAfter !== undefined) out.retryAfter = r.retryAfter;
+  return out;
+}
+
+const invalid = (mensagem) => ({ ok: false, codigo: 'invalido', mensagem });
+const unexpected = (mensagem) => ({ ok: false, codigo: 'falha', mensagem });
+
+/** Envolve a operacao: cliente ausente ou excecao inesperada viram `{ ok:false }`, nunca lancam. */
+function op(fn) {
+  return async (client, ...args) => {
+    try {
+      if (!client || typeof client.request !== 'function') return unexpected('cliente da API ausente');
+      return await fn(client, ...args);
+    } catch {
+      return unexpected('erro inesperado ao falar com o Infisical');
+    }
+  };
+}
+
+function str(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+
+/** Aceita `(valor, extras)` ou um objeto unico `{ [chave]: valor, ...extras }`. */
+function params(first, key, rest) {
+  const base = first && typeof first === 'object' ? { ...first } : { [key]: first };
+  if (rest && typeof rest === 'object') Object.assign(base, rest);
+  return base;
+}
+
+function normProject(raw) {
+  const p = raw && typeof raw === 'object' ? (raw.project && typeof raw.project === 'object' ? raw.project : raw) : null;
+  if (!p || typeof p.id !== 'string' || !p.id) return null;
+  const environments = Array.isArray(p.environments)
+    ? p.environments
+        .filter((e) => e && typeof e.slug === 'string')
+        .map((e) => ({ slug: e.slug, name: typeof e.name === 'string' ? e.name : e.slug }))
+    : [];
+  return {
+    id: p.id,
+    name: typeof p.name === 'string' ? p.name : '',
+    slug: typeof p.slug === 'string' ? p.slug : '',
+    type: typeof p.type === 'string' ? p.type : '',
+    orgId: typeof p.orgId === 'string' && p.orgId ? p.orgId : null,
+    environments,
+  };
+}
+
+function normIdentity(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const wrapped = raw.identity && typeof raw.identity === 'object';
+  const base = wrapped ? raw.identity : raw;
+  const id = typeof base.id === 'string' && base.id ? base.id : typeof raw.identityId === 'string' ? raw.identityId : '';
+  if (!id) return null;
+  const projectId = base.projectId || raw.projectId;
+  return {
+    id,
+    name: typeof base.name === 'string' ? base.name : '',
+    projectId: typeof projectId === 'string' && projectId ? projectId : null,
+    authMethods: Array.isArray(base.authMethods) ? base.authMethods.filter((m) => typeof m === 'string') : [],
+  };
+}
+
+const listOrganizations = op(async (client) => {
+  const r = await client.request('GET', '/api/v1/organization');
+  if (!r.ok) return opFail(r);
+  const lista = r.data && Array.isArray(r.data.organizations) ? r.data.organizations : null;
+  if (!lista) return unexpected('resposta inesperada ao listar organizacoes');
+  const orgs = lista
+    .filter((x) => x && typeof x.id === 'string' && x.id)
+    .map((x) => ({ id: x.id, name: typeof x.name === 'string' ? x.name : '', userRole: typeof x.userRole === 'string' ? x.userRole : null }));
+  return { ok: true, orgs };
+});
+
+const getProjectBySlug = op(async (client, first) => {
+  const slug = str(params(first, 'slug').slug);
+  if (!slug) return invalid('falta o slug do projeto');
+  const r = await client.request('GET', `/api/v1/projects/slug/${enc(slug)}`);
+  if (!r.ok) return opFail(r);
+  const project = normProject(r.data);
+  return project ? { ok: true, project } : unexpected('resposta inesperada ao buscar o projeto');
+});
+
+const createProject = op(async (client, first) => {
+  const a = first && typeof first === 'object' ? first : {};
+  const name = str(a.name);
+  const slug = str(a.slug);
+  if (!name || !slug) return invalid('falta nome e slug do projeto');
+  const r = await client.request('POST', '/api/v1/projects', { body: { projectName: name, slug } });
+  if (!r.ok) return opFail(r);
+  const project = normProject(r.data);
+  return project ? { ok: true, project } : unexpected('resposta inesperada ao criar o projeto');
+});
+
+const listProjectIdentities = op(async (client, first, rest) => {
+  const a = params(first, 'projectId', rest);
+  const projectId = str(a.projectId);
+  if (!projectId) return invalid('falta o id do projeto');
+  const query = { limit: 50 };
+  const search = str(a.search);
+  if (search) query.search = search;
+  const r = await client.request('GET', `/api/v1/projects/${enc(projectId)}/identities`, { query });
+  if (!r.ok) return opFail(r);
+  const lista = r.data && Array.isArray(r.data.identities) ? r.data.identities : null;
+  if (!lista) return unexpected('resposta inesperada ao listar identidades');
+  return { ok: true, identities: lista.map(normIdentity).filter(Boolean) };
+});
+
+const createProjectIdentity = op(async (client, first, rest) => {
+  const a = params(first, 'projectId', rest);
+  const projectId = str(a.projectId);
+  const name = str(a.name);
+  const role = str(a.role) || 'member';
+  if (!projectId || !name) return invalid('falta o id do projeto e o nome da identidade');
+  const r = await client.request('POST', `/api/v1/projects/${enc(projectId)}/identities`, {
+    body: { name, roles: [{ role, isTemporary: false }] },
+  });
+  if (!r.ok) return opFail(r);
+  const identity = normIdentity(r.data && r.data.identity);
+  return identity ? { ok: true, identity } : unexpected('resposta inesperada ao criar a identidade');
+});
+
+const getUniversalAuth = op(async (client, first) => {
+  const identityId = str(params(first, 'identityId').identityId);
+  if (!identityId) return invalid('falta o id da identidade');
+  const r = await client.request('GET', `/api/v1/auth/universal-auth/identities/${enc(identityId)}`);
+  if (!r.ok) return opFail(r);
+  const clientId = r.data && r.data.identityUniversalAuth && r.data.identityUniversalAuth.clientId;
+  return typeof clientId === 'string' && clientId ? { ok: true, clientId } : unexpected('resposta inesperada ao ler o Universal Auth');
+});
+
+const attachUniversalAuth = op(async (client, first, rest) => {
+  const a = params(first, 'identityId', rest);
+  const identityId = str(a.identityId);
+  if (!identityId) return invalid('falta o id da identidade');
+  const accessTokenTTL = Number.isInteger(a.accessTokenTTL) ? a.accessTokenTTL : 3600;
+  const accessTokenMaxTTL = Number.isInteger(a.accessTokenMaxTTL) ? a.accessTokenMaxTTL : 86400;
+  const r = await client.request('POST', `/api/v1/auth/universal-auth/identities/${enc(identityId)}`, {
+    body: { accessTokenTTL, accessTokenMaxTTL },
+  });
+  if (r.ok) {
+    const clientId = r.data && r.data.identityUniversalAuth && r.data.identityUniversalAuth.clientId;
+    return typeof clientId === 'string' && clientId ? { ok: true, clientId, jaExistia: false } : unexpected('resposta inesperada ao anexar o Universal Auth');
+  }
+  if (r.codigo === 'ja-existe') {
+    const atual = await getUniversalAuth(client, identityId);
+    return atual.ok ? { ok: true, clientId: atual.clientId, jaExistia: true } : atual;
+  }
+  return opFail(r);
+});
+
+const createClientSecret = op(async (client, first, rest) => {
+  const a = params(first, 'identityId', rest);
+  const identityId = str(a.identityId);
+  if (!identityId) return invalid('falta o id da identidade');
+  const description = typeof a.description === 'string' ? a.description : '';
+  const r = await client.request('POST', `/api/v1/auth/universal-auth/identities/${enc(identityId)}/client-secrets`, {
+    body: { description, numUsesLimit: 0, ttl: 0 },
+  });
+  if (!r.ok) return opFail(r);
+  const clientSecret = r.data && r.data.clientSecret;
+  if (typeof clientSecret !== 'string' || !clientSecret) return unexpected('resposta inesperada ao criar a chave');
+  const secretId = r.data.clientSecretData && typeof r.data.clientSecretData.id === 'string' ? r.data.clientSecretData.id : null;
+  return { ok: true, clientSecret, secretId };
+});
+
+const listClientSecrets = op(async (client, first) => {
+  const identityId = str(params(first, 'identityId').identityId);
+  if (!identityId) return invalid('falta o id da identidade');
+  const r = await client.request('GET', `/api/v1/auth/universal-auth/identities/${enc(identityId)}/client-secrets`);
+  if (!r.ok) return opFail(r);
+  const lista = r.data && Array.isArray(r.data.clientSecretData) ? r.data.clientSecretData : null;
+  if (!lista) return unexpected('resposta inesperada ao listar as chaves');
+  const secrets = lista
+    .filter((s) => s && typeof s.id === 'string' && s.id)
+    .map((s) => ({
+      id: s.id,
+      description: typeof s.description === 'string' ? s.description : '',
+      // 4 primeiros caracteres da chave (o Infisical os mostra na lista): so para reconhecer a chave EM USO neste computador.
+      // Nunca vai para tela, log nem config.
+      prefix: typeof s.clientSecretPrefix === 'string' ? s.clientSecretPrefix.slice(0, 16) : '',
+      createdAt: typeof s.createdAt === 'string' ? s.createdAt : null,
+      revoked: s.isClientSecretRevoked === true,
+    }));
+  return { ok: true, secrets };
+});
+
+const revokeClientSecret = op(async (client, first, second) => {
+  const a = first && typeof first === 'object' ? first : { identityId: first, secretId: second };
+  const identityId = str(a.identityId);
+  const secretId = str(a.secretId);
+  if (!identityId || !secretId) return invalid('falta o id da identidade e o id da chave');
+  const r = await client.request(
+    'POST',
+    `/api/v1/auth/universal-auth/identities/${enc(identityId)}/client-secrets/${enc(secretId)}/revoke`,
+    { repetir: true }, // revogar de novo uma chave ja revogada nao muda nada
+  );
+  return r.ok ? { ok: true } : opFail(r);
+});
+
+const universalLogin = op(async (client, first) => {
+  const a = first && typeof first === 'object' ? first : {};
+  const clientId = str(a.clientId);
+  const clientSecret = str(a.clientSecret);
+  if (!clientId || !clientSecret) return invalid('falta o client id e o client secret');
+  const r = await client.request('POST', '/api/v1/auth/universal-auth/login', { auth: 'none', repetir: true, body: { clientId, clientSecret } });
+  if (!r.ok) return opFail(r);
+  const accessToken = r.data && r.data.accessToken;
+  if (typeof accessToken !== 'string' || !accessToken) return unexpected('resposta inesperada no login da identidade');
+  const expiresIn = Number(r.data.expiresIn);
+  return { ok: true, accessToken, expiresIn: Number.isFinite(expiresIn) ? expiresIn : null };
+});
+
+/** Valida `{ projectId, environment, name }` (e `value` quando pedido). Devolve texto de erro ou null. */
+function secretArgsProblem(a, needValue) {
+  if (!str(a.projectId) || !str(a.environment)) return 'falta o projeto e o ambiente';
+  if (typeof a.name !== 'string' || !a.name) return 'falta o nome do segredo';
+  if (needValue && typeof a.value !== 'string') return 'o valor do segredo precisa ser texto';
+  return null;
+}
+
+const readSecret = op(async (client, first) => {
+  const a = first && typeof first === 'object' ? first : {};
+  const problem = secretArgsProblem(a, false);
+  if (problem) return invalid(problem);
+  // expandSecretReferences=false: a v4 expande ${...} por padrao e devolveria um valor diferente do gravado
+  const r = await client.request('GET', `/api/v4/secrets/${enc(a.name)}`, {
+    query: { projectId: a.projectId, environment: a.environment, secretPath: '/', type: 'shared', expandSecretReferences: 'false' },
+  });
+  if (!r.ok) return opFail(r);
+  const secret = r.data && r.data.secret;
+  if (!secret || typeof secret !== 'object') return unexpected('resposta inesperada ao ler o segredo');
+  if (secret.secretValueHidden === true || secret.secretValue === HIDDEN_VALUE) {
+    return { ok: false, codigo: 'sem-permissao', mensagem: 'esta identidade nao pode ver o valor do segredo' };
+  }
+  if (typeof secret.secretValue !== 'string') return unexpected('a resposta nao trouxe o valor do segredo');
+  return { ok: true, value: secret.secretValue };
+});
+
+const writeSecret = op(async (client, first) => {
+  const a = first && typeof first === 'object' ? first : {};
+  const problem = secretArgsProblem(a, true);
+  if (problem) return invalid(problem);
+  const caminho = `/api/v4/secrets/${enc(a.name)}`;
+  const corpo = () => ({ projectId: a.projectId, environment: a.environment, secretPath: '/', secretValue: a.value, type: 'shared' });
+  let r = await client.request('POST', caminho, { body: corpo() });
+  let criado = true;
+  if (!r.ok && r.codigo === 'ja-existe') {
+    criado = false;
+    r = await client.request('PATCH', caminho, { body: corpo() });
+  }
+  if (!r.ok) return opFail(r);
+  if (r.data && r.data.approval && !r.data.secret) return unexpected('o projeto exige aprovacao para gravar segredos');
+  return { ok: true, criado };
+});
+
+const listSecretNames = op(async (client, first) => {
+  const a = first && typeof first === 'object' ? first : {};
+  if (!str(a.projectId) || !str(a.environment)) return invalid('falta o projeto e o ambiente');
+  const r = await client.request('GET', '/api/v4/secrets', {
+    query: { projectId: a.projectId, environment: a.environment, secretPath: '/', viewSecretValue: 'false' },
+  });
+  if (!r.ok) return opFail(r);
+  const lista = r.data && Array.isArray(r.data.secrets) ? r.data.secrets : null;
+  if (!lista) return unexpected('resposta inesperada ao listar segredos');
+  const names = [];
+  for (const s of lista) {
+    // so a chave interessa: se a API mandou valor, ele e descartado aqui
+    if (s && typeof s.secretKey === 'string' && s.secretKey && !names.includes(s.secretKey)) names.push(s.secretKey);
+  }
+  return { ok: true, names };
+});
+
+const deleteSecret = op(async (client, first) => {
+  const a = first && typeof first === 'object' ? first : {};
+  const problem = secretArgsProblem(a, false);
+  if (problem) return invalid(problem);
+  const r = await client.request('DELETE', `/api/v4/secrets/${enc(a.name)}`, {
+    body: { projectId: a.projectId, environment: a.environment, secretPath: '/' },
+  });
+  return r.ok ? { ok: true } : opFail(r);
+});
+
+module.exports = {
+  REGIONS,
+  normalizeDomain,
+  decodeJwtPayload,
+  isJwtShape,
+  isClientSecretShape,
+  redact,
+  createClient,
+  classifyHttp,
+  ops: {
+    listOrganizations,
+    getProjectBySlug,
+    createProject,
+    listProjectIdentities,
+    createProjectIdentity,
+    getUniversalAuth,
+    attachUniversalAuth,
+    createClientSecret,
+    listClientSecrets,
+    revokeClientSecret,
+    universalLogin,
+    readSecret,
+    writeSecret,
+    listSecretNames,
+    deleteSecret,
+  },
+};