auroq-os 2.4.16 → 2.4.18

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

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

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [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
+- O `doctor` (e o `init`/`register-mcp`) abriam o `npx` com `shell: true` no Windows, e o Node 24
+  imprimia um `DeprecationWarning` no meio do diagnostico do aluno. Agora chama o `cmd.exe`
+  direto — sem aviso.
+- Aluno com Node proprio (sem o motor de bolso) recebia um X — "O motor esta valendo nesta
+  janela" — e a ordem de rodar o instalador de novo, com tudo funcionando. No Windows o caminho
+  e da conta, nao da janela: motor encontrado = OK.
+
 ## [2.4.16] — 2026-09-04
 
 ### Codex no Windows: conteudo ao vivo abria, mas "Sem conexao com o servidor da Arcane" (EMB-028)

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.');
@@ -449,12 +490,22 @@ function blocoCodexArcane(pin, opcoes) {
 
 // Baixa o pacote do conteudo ao vivo com o MESMO nome que o registro usa (o cache do
 // npx e por nome+versao: `arcane-mcp` e `arcane-mcp@0.4.1` sao caches diferentes).
+// `npx` no Windows e um .cmd: sem shell o Node recusa (EINVAL) e com `shell: true` o Node 24
+// imprime um DeprecationWarning na tela do aluno (DEP0190). Chamar o cmd.exe direto, sem shell.
+function comandoNpx(args) {
+  if (process.platform !== 'win32') return { cmd: 'npx', args, opts: {} };
+  return {
+    cmd: process.env.ComSpec || 'cmd.exe',
+    args: ['/d', '/s', '/c', `npx ${args.join(' ')}`],
+    opts: { windowsVerbatimArguments: true },
+  };
+}
+
 function aquecerArcaneMcp() {
   if (process.env.NODE_ENV === 'test' && process.env.AUROQ_SKIP_AUTH === '1') return true;
   try {
-    execFileSync('npx', ['-y', ARCANE_MCP_PIN, 'whoami'], {
-      stdio: 'pipe', timeout: 240000, shell: process.platform === 'win32',
-    });
+    const c = comandoNpx(['-y', ARCANE_MCP_PIN, 'whoami']);
+    execFileSync(c.cmd, c.args, { stdio: 'pipe', timeout: 240000, ...c.opts });
     return true;
   } catch {
     return false;
@@ -479,9 +530,8 @@ function medirArranqueArcaneMcp(pin, limiteMs = 180000) {
     };
     const timer = setTimeout(() => fecha(null), limiteMs);
     try {
-      processo = spawn('npx', ['-y', pin], {
-        stdio: ['pipe', 'pipe', 'pipe'], shell: process.platform === 'win32',
-      });
+      const c = comandoNpx(['-y', pin]);
+      processo = spawn(c.cmd, c.args, { stdio: ['pipe', 'pipe', 'pipe'], ...c.opts });
     } catch {
       clearTimeout(timer);
       resolve(null);
@@ -522,6 +572,142 @@ 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.
+const CODEX_ENV_MINIMO = ['PATH', 'PATHEXT', 'USERNAME', 'USERDOMAIN', 'USERPROFILE', 'TEMP', 'TMP',
+  'HOME', 'LOGNAME', 'SHELL', 'TERM', 'USER'];
+
+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 = {};
+    for (const k of Object.keys(process.env)) {
+      if (CODEX_ENV_MINIMO.some(n => n.toLowerCase() === k.toLowerCase())) env[k] = process.env[k];
+    }
+    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');
@@ -1410,4 +1596,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 };

package/lib/diagnostico.js

@@ -38,11 +38,13 @@ function appEnxergaMotor({ homeDir, pathAtual = '', caminhoMotor = '', plataform
   const partes = String(pathAtual).split(plataforma === 'win32' ? ';' : ':').filter(Boolean);
 
   if (plataforma === 'win32') {
-    const temAuroq = partes.some((p) => /auroq/i.test(p));
+    // No Windows o caminho e da conta do usuario, nao da janela: o que vale aqui vale
+    // pro icone. Aluno com Node proprio (sem o motor de bolso) nao e defeito — acusar
+    // isso mandava gente com tudo funcionando "rodar o instalador de novo" (04/09).
     return {
-      visivel: partes.length > 0,
+      visivel: partes.length > 0 || Boolean(caminhoMotor),
       perfisSemBloco: [],
-      motivo: temAuroq ? '' : 'O motor esta valendo nesta janela.',
+      motivo: (partes.length > 0 || caminhoMotor) ? '' : 'Nenhum motor no caminho desta conta.',
     };
   }
 

package/package.json

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