auroq-os 2.4.17 → 2.4.19

package/.auroq-core/core-config.yaml

@@ -1,7 +1,7 @@
 project:
   name: "Auroq OS"
   type: greenfield
-  version: 2.4.17
+  version: 2.4.19
   installedAt: '2026-03-16'
 
 ide:

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [2.4.19] — 2026-09-04
+
+### O npx guarda cache por ambiente — o Codex abria "a frio" mesmo depois de aquecido
+Medido em Windows limpo: com o pacote ja baixado no PowerShell (2s), a primeira abertura com o
+ambiente que o Codex da ao MCP ainda levava 45-53s. Cada ambiente tem o seu cache. E o que
+explica a aluna ver timeout (30s) ontem e "ferramenta indisponivel" hoje, com o `doctor` limpo.
+- `init`, `update` e `register-mcp` aquecem os DOIS ambientes no Windows: o do terminal e o
+  do Codex (minimo + variaveis do registro).
+- O `doctor` ja abria "como o Codex abre" (2.4.18); agora esse passo usa exatamente o mesmo
+  ambiente do aquecimento, entao ele tambem prepara a maquina.
+
+## [2.4.18] — 2026-09-04
+
+### Doctor faz o trabalho do suporte numa tela so (Codex)
+Caso EMB-028 virou ping-pong com a aluna ("roda isso, agora aquilo, manda o print"). Agora o
+`doctor`, quando o projeto tem registro no Codex:
+- mostra a versao do Codex e o bloco `[mcp_servers.arcane]` da pasta;
+- **tira um registro duplicado do arcane do config global** do Codex (`~/.codex/config.toml`),
+  com backup — e o que briga com o registro da pasta;
+- **abre o conteudo ao vivo do jeito que o Codex abre** (ambiente minimo do Windows + env do
+  registro), lista as ferramentas, confere se `forja_bundle` esta la e chama `catalogo_listar`;
+- imprime as ultimas linhas do log do Codex sobre o arcane e o stderr do MCP;
+- se algo falhou, o unico pedido e "mande o print desta tela inteira".
+
 ## [2.4.17] — 2026-09-04
 
 ### Doctor no Windows: tela limpa

package/bin/auroq-os.js

@@ -390,6 +390,47 @@ async function runDoctor(targetDir) {
     }
   }
 
+  // 7. Codex — relatorio completo numa tela so (EMB-028). Nada de pedir comando por comando.
+  if (pin && !semArranque && temToml) {
+    log('');
+    log(`  ${CYAN}Codex — relatorio pro suporte${RESET}`);
+    const vCodex = versaoDoCodex();
+    if (vCodex) success(`Codex: ${vCodex}`);
+    else warn('Codex nao encontrado nesta janela (so importa se voce usa o Codex)');
+
+    const globalPath = path.join(require('os').homedir(), '.codex', 'config.toml');
+    const g = await limparArcaneDoGlobal(globalPath);
+    if (g.existia) {
+      log(`  ${DIM}Config global do Codex: ${g.servidores.length} servidor(es)${g.servidores.length ? ` (${g.servidores.join(', ')})` : ''}${RESET}`);
+      if (g.removido) success(`Registro duplicado do arcane no global: removido (backup em ${path.basename(g.backup)})`);
+    }
+
+    const bloco = lerBlocoArcane(tomlTexto);
+    for (const l of bloco.split('\n').filter(l => l && !l.startsWith('#'))) log(`  ${DIM}  ${l.length > 160 ? `${l.slice(0, 157)}...` : l}${RESET}`);
+
+    log(`  ${DIM}Abrindo o conteudo ao vivo do jeito que o Codex abre (ambiente minimo + registro)...${RESET}`);
+    const r = await abrirComoCodex(pin, lerEnvDoBloco(bloco));
+    if (r.subiu === null) {
+      error('Aberto como o Codex abre: NAO respondeu');
+    } else {
+      const ferramentas = r.tools ? `${r.tools.length} ferramentas (forja_bundle: ${r.temForja ? 'sim' : 'NAO'})` : 'ferramentas: sem resposta';
+      const chamada = r.chamada
+        ? (r.chamada.erro ? `catalogo_listar: ERRO — ${r.chamada.texto}` : `catalogo_listar: OK — ${r.chamada.texto}`)
+        : 'catalogo_listar: sem resposta';
+      (r.temForja && r.chamada && !r.chamada.erro ? success : error)(`Aberto como o Codex abre: ${(r.subiu / 1000).toFixed(1)}s · ${ferramentas} · ${chamada}`);
+    }
+    if (r.stderr) for (const l of r.stderr.split('\n').slice(-4)) log(`  ${DIM}  stderr: ${l.slice(0, 160)}${RESET}`);
+
+    const rastro = await rastroDoCodex();
+    if (rastro.length) {
+      log(`  ${DIM}Ultimas linhas do log do Codex sobre o arcane:${RESET}`);
+      for (const l of rastro) log(`  ${DIM}  ${l}${RESET}`);
+    }
+    if (r.subiu === null || !r.temForja || !r.chamada || r.chamada.erro) {
+      problemas.push('Mande o print desta tela INTEIRA pro suporte (11 93621-4486) — ela ja traz tudo que precisamos.');
+    }
+  }
+
   log('');
   if (problemas.length === 0) {
     success('Tudo certo. Pode chamar o Companion.');
@@ -411,6 +452,9 @@ async function runDoctor(targetDir) {
 // pacote, (3) o doctor mede o arranque de verdade em vez de so olhar o registro.
 const ARCANE_MCP_PIN = 'arcane-mcp@0.4.1';
 const CODEX_MCP_STARTUP_SEC = 120;
+const CODEX_ENV_MINIMO = ['PATH', 'PATHEXT', 'USERNAME', 'USERDOMAIN', 'USERPROFILE', 'TEMP', 'TMP',
+  'HOME', 'LOGNAME', 'SHELL', 'TERM', 'USER'];
+
 const MCP_ARRANQUE_LIMITE_MS = 9000; // abaixo do que o Codex tolera (10s)
 
 // No Windows o Codex abre o MCP com um ambiente minimo (PATH, USERNAME, USERPROFILE,
@@ -460,15 +504,39 @@ function comandoNpx(args) {
   };
 }
 
+// O ambiente que o Codex da ao MCP no Windows (minimo + o env do registro). Medido em
+// 04/09/2026 (windows-latest): o npx guarda cache POR AMBIENTE — aquecido no PowerShell
+// (2s), a primeira abertura pelo Codex ainda levava 45-53s. Por isso aquecemos os dois.
+function envComoCodex({ plataforma = process.platform, env = process.env } = {}) {
+  const base = {};
+  for (const k of Object.keys(env)) {
+    if (CODEX_ENV_MINIMO.some(n => n.toLowerCase() === k.toLowerCase())) base[k] = env[k];
+  }
+  if (plataforma === 'win32') {
+    for (const nome of CODEX_ENV_WINDOWS) {
+      const chave = Object.keys(env).find(k => k.toLowerCase() === nome.toLowerCase());
+      if (chave && env[chave]) base[nome] = env[chave];
+    }
+  }
+  return base;
+}
+
 function aquecerArcaneMcp() {
   if (process.env.NODE_ENV === 'test' && process.env.AUROQ_SKIP_AUTH === '1') return true;
+  const c = comandoNpx(['-y', ARCANE_MCP_PIN, 'whoami']);
   try {
-    const c = comandoNpx(['-y', ARCANE_MCP_PIN, 'whoami']);
     execFileSync(c.cmd, c.args, { stdio: 'pipe', timeout: 240000, ...c.opts });
-    return true;
   } catch {
     return false;
   }
+  if (process.platform === 'win32') {
+    try {
+      execFileSync(c.cmd, c.args, { stdio: 'pipe', timeout: 240000, env: envComoCodex(), ...c.opts });
+    } catch {
+      return false;
+    }
+  }
+  return true;
 }
 
 // Abre o conteudo ao vivo do jeito que o Codex/Claude Code abrem e mede quanto tempo
@@ -531,6 +599,137 @@ async function guardarBootstrapLocal(targetDir, file, dst, dstExists) {
   return true;
 }
 
+
+// ── Codex: imitar EXATAMENTE como ele abre o conteudo ao vivo ────────────────
+// O aluno nao pode virar o nosso laboratorio ("roda isso, agora aquilo"). O doctor
+// abre o MCP com o mesmo ambiente minimo que o Codex usa no Windows (openai/codex#4180)
+// mais o env do registro, lista as ferramentas e chama uma. Se aqui funciona e no
+// Codex nao, o problema e do lado do Codex — e o log dele entra no relatorio.
+
+function lerBlocoArcane(toml) {
+  const m = String(toml || '').match(/\[mcp_servers\.arcane\][\s\S]*?(?=\n\[|$(?![\s\S]))/);
+  return m ? m[0] : '';
+}
+
+function lerEnvDoBloco(bloco) {
+  const env = {};
+  const m = String(bloco || '').match(/^env = \{ (.*) \}$/m);
+  if (!m) return env;
+  for (const par of m[1].split(', ')) {
+    const i = par.indexOf(' = ');
+    if (i < 0) continue;
+    env[par.slice(0, i).trim()] = par.slice(i + 3).replace(/^['"]|['"]$/g, '');
+  }
+  return env;
+}
+
+function abrirComoCodex(pin, envBloco, limiteMs = 120000) {
+  return new Promise((resolve) => {
+    const { spawn } = require('child_process');
+    const env = envComoCodex();
+    Object.assign(env, envBloco || {});
+    const c = comandoNpx(['-y', pin]);
+    const t0 = Date.now();
+    const r = { subiu: null, tools: null, temForja: false, chamada: null, stderr: '' };
+    let saida = '';
+    let erro = '';
+    let fim = false;
+    let p;
+    const fecha = () => {
+      if (fim) return;
+      fim = true;
+      clearTimeout(timer);
+      try { p.kill(); } catch { /* ja morreu */ }
+      r.stderr = erro.trim().slice(-600);
+      resolve(r);
+    };
+    const timer = setTimeout(fecha, limiteMs);
+    try {
+      p = spawn(c.cmd, c.args, { stdio: ['pipe', 'pipe', 'pipe'], env, ...c.opts });
+    } catch (e) {
+      clearTimeout(timer);
+      r.chamada = { erro: true, texto: `nao abriu: ${e.message}` };
+      resolve(r);
+      return;
+    }
+    const envia = (o) => { try { p.stdin.write(`${JSON.stringify(o)}\n`); } catch { /* fechou */ } };
+    p.stderr.on('data', (d) => { erro += d.toString(); });
+    p.on('exit', fecha);
+    p.on('error', fecha);
+    p.stdout.on('data', (d) => {
+      saida += d.toString();
+      let idx;
+      while ((idx = saida.indexOf('\n')) >= 0) {
+        const linha = saida.slice(0, idx);
+        saida = saida.slice(idx + 1);
+        let msg;
+        try { msg = JSON.parse(linha); } catch { continue; }
+        if (msg.id === 1) {
+          r.subiu = Date.now() - t0;
+          envia({ jsonrpc: '2.0', method: 'notifications/initialized' });
+          envia({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+        } else if (msg.id === 2) {
+          r.tools = (msg.result?.tools || []).map(t => t.name);
+          r.temForja = r.tools.includes('forja_bundle');
+          envia({ jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'catalogo_listar', arguments: {} } });
+        } else if (msg.id === 3) {
+          const texto = msg.result?.content?.[0]?.text || JSON.stringify(msg.error || msg.result || '');
+          r.chamada = {
+            erro: Boolean(msg.result?.isError || msg.error),
+            texto: String(texto).replace(/<!--.*?-->/g, '').split('\n').filter(Boolean).slice(0, 2).join(' ').slice(0, 220),
+          };
+          fecha();
+        }
+      }
+    });
+    envia({
+      jsonrpc: '2.0', id: 1, method: 'initialize',
+      params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'auroq-doctor-codex', version: '0' } },
+    });
+  });
+}
+
+// Registro do arcane no config GLOBAL do Codex (~/.codex/config.toml) briga com o da
+// pasta. Sai de la, com backup; o da pasta e o que vale.
+async function limparArcaneDoGlobal(caminho) {
+  if (!(await fs.pathExists(caminho))) return { existia: false, servidores: [], removido: false };
+  const toml = await fs.readFile(caminho, 'utf8');
+  const servidores = [...new Set([...toml.matchAll(/^\[mcp_servers\.([^\].]+)/gm)].map(m => m[1]))];
+  if (!/^\[mcp_servers\.arcane(\.|\])/m.test(toml)) return { existia: true, servidores, removido: false };
+  const backup = `${caminho}.bak-${new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-')}`;
+  await fs.writeFile(backup, toml);
+  const novo = toml.replace(/\n*\[mcp_servers\.arcane(\.[^\]]+)?\][\s\S]*?(?=\n\[|$(?![\s\S]))/g, '');
+  await fs.writeFile(caminho, `${novo.trimEnd()}\n`);
+  return { existia: true, servidores, removido: true, backup };
+}
+
+function versaoDoCodex() {
+  try {
+    const c = process.platform === 'win32'
+      ? { cmd: process.env.ComSpec || 'cmd.exe', args: ['/d', '/s', '/c', 'codex --version'], opts: { windowsVerbatimArguments: true } }
+      : { cmd: 'codex', args: ['--version'], opts: {} };
+    return execFileSync(c.cmd, c.args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 20000, ...c.opts }).trim();
+  } catch {
+    return '';
+  }
+}
+
+async function rastroDoCodex(limite = 8) {
+  const arq = path.join(require('os').homedir(), '.codex', 'log', 'codex-tui.log');
+  try {
+    const st = await fs.stat(arq);
+    const fd = await fs.open(arq, 'r');
+    const tam = Math.min(st.size, 400000);
+    const buf = Buffer.alloc(tam);
+    await fs.read(fd, buf, 0, tam, st.size - tam);
+    await fs.close(fd);
+    const linhas = buf.toString('utf8').split('\n').filter(l => /arcane/i.test(l));
+    return linhas.slice(-limite).map(l => l.replace(/\u001b\[[0-9;]*m/g, '').slice(0, 200));
+  } catch {
+    return [];
+  }
+}
+
 async function writeArcaneMcpConfig(targetDir) {
   const pin = ARCANE_MCP_PIN;
   const mcpPath = path.join(targetDir, '.mcp.json');
@@ -980,7 +1179,7 @@ async function init({ pasta = null } = {}) {
   }
   await patchEnableAllProjectMcpServers(targetDir);
   await writeArcaneMcpConfig(targetDir);
-  step('Preparando o conteudo ao vivo (baixa uma vez; pode levar 1-2 min)...');
+  step('Preparando o conteudo ao vivo (baixa uma vez; no Windows prepara tambem pro Codex; pode levar 1-3 min)...');
   if (aquecerArcaneMcp()) success('Conteudo ao vivo pronto pra abrir rapido');
   else warn('Nao consegui baixar o conteudo ao vivo agora — a primeira abertura vai demorar mais');
 
@@ -1258,7 +1457,7 @@ async function clone(repoArg) {
   }
 
   await writeArcaneMcpConfig(destDir);
-  step('Preparando o conteudo ao vivo (baixa uma vez; pode levar 1-2 min)...');
+  step('Preparando o conteudo ao vivo (baixa uma vez; no Windows prepara tambem pro Codex; pode levar 1-3 min)...');
   if (aquecerArcaneMcp()) success('Conteudo ao vivo pronto pra abrir rapido');
   else warn('Nao consegui baixar o conteudo ao vivo agora — a primeira abertura vai demorar mais');
 
@@ -1419,4 +1618,4 @@ if (command === 'init' || command === 'install') {
   log('');
 }
 
-if (process.env.AUROQ_EXPORTA_INTERNOS === '1') module.exports = { blocoCodexArcane, envCodexArcane };
+if (process.env.AUROQ_EXPORTA_INTERNOS === '1') module.exports = { blocoCodexArcane, envCodexArcane, lerBlocoArcane, lerEnvDoBloco, limparArcaneDoGlobal, envComoCodex };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auroq-os",
-  "version": "2.4.17",
+  "version": "2.4.19",
   "description": "Auroq OS — Sistema Operacional de IA para Experts",
   "bin": {
     "auroq-os": "bin/auroq-os.js"