chatflux-gestao-agente 0.2.2 → 0.2.4

package/README.md

@@ -8,15 +8,46 @@ faz na tela, e tudo no histórico com o seu nome.
 > nova, o que exige (e o que não exige) republicar, como testar sem browser, e as
 > armadilhas que já custaram tempo. Ele fica só no repo — não vai no npm.
 
+## Atualizar pelo portal
+
+No aviso “Atualize o ChatFlux neste computador”, clique **Atualizar**. Com o
+computador conectado e o programa 0.2.4 ou mais recente, o portal acompanha a
+configuração completa, sem terminal. Se precisar renovar o login, o navegador
+abre. Ao aparecer **Pronto ✓**, reinicie o VS Code; o aviso some sozinho.
+
+Sem conexão, o botão mostra um pedido para copiar no Claude Code ou no Codex.
+Cole, aprove quando a IA pedir e acompanhe: ela executa o comando abaixo. Em
+programas antigos, o botão atualiza os plugins e mostra esse mesmo painel para
+completar a preparação. “Ver detalhes” explica o motivo do aviso e “Agora não”
+o dispensa nesta sessão.
+
 ## Instalar (equipe — um comando, sem clonar nada)
 
 ```sh
-claude mcp add --scope user gestao -- npx -y chatflux-gestao-agente mcp
+npx -y chatflux-gestao-agente@latest configurar
 ```
 
-Pronto. Abra o Claude Code e peça qualquer coisa do portal: na primeira vez ele
-mesmo abre o navegador para você autorizar. **Você não digita mais nenhum
-comando** — nem `login`, nem `status`.
+No Terminal do Mac ou PowerShell do Windows, esse comando instala a cópia
+permanente do programa, confere a loja oficial de plugins do Claude Code e do
+Codex, atualiza o `chatflux-app`, renova o login quando necessário (abre o
+navegador) e registra/liga o computador. Ferramentas ausentes são puladas; cada
+etapa mostra seu resultado e o que ainda falta fazer. Reinicie o VS Code ao final.
+
+Para trocar uma loja antiga, ele pede confirmação. Use `--sim` para autorizar sem
+perguntas, ou `--verificar` para apenas diagnosticar, sem instalar, atualizar,
+abrir login ou ligar o computador. O toolkit é privado: sua conta do GitHub
+precisa ter acesso a `Chatflux-Infra-Tools/chatflux-agent-toolkit`.
+
+Depois da instalação, você também pode rodar `gestao configurar`. Se o npm negar
+permissão para instalar globalmente, configure o Node/npm em uma pasta do seu
+usuário e repita, sem sudo nem administrador. Login e ligação do computador
+usam sempre a cópia permanente, nunca o cache temporário do npx.
+
+Para registrar o conector MCP diretamente no Claude Code:
+
+```sh
+claude mcp add --scope user gestao -- gestao mcp
+```
 
 ### Instalar (desenvolvimento, dentro deste repo)
 

package/bin/gestao.mjs

@@ -14,6 +14,7 @@ const AJUDA = `gestao — portal Gestão pela linha de comando e por agente (MCP
 
   gestao login     autoriza este computador a agir como você (abre o navegador)
   gestao status    mostra quem está conectado e quanto tempo falta
+  gestao configurar [--verificar] [--sim]  prepara plugins, login e computador
   gestao ligar     instala início automático e associa este computador ao navegador
   gestao desligar  remove início automático e interrompe o computador, mesmo offline
   gestao computador executar  residente técnico (usado pelo login do SO)
@@ -30,6 +31,11 @@ const [, , verbo] = process.argv;
 
 try {
   switch (verbo) {
+    case "configurar": {
+      const { configurar } = await import("../lib/configurar.mjs");
+      await configurar(process.argv.slice(3));
+      break;
+    }
     case "login": {
       if (nomeServico()) {
         console.error("Modo serviço (GESTAO_SERVICO) ativo: não há login de pessoa. Use `gestao status`.");

package/lib/computador-estado.mjs

@@ -49,6 +49,7 @@ const privateResult = x => ({
   baixar_abrir: shape({ kind: oneOf('baixar_abrir'), canonicalPath: text, ...opening }),
   escolher_pasta_projeto: shape({ kind: oneOf('escolher_pasta_projeto'), canonicalPath: text, ...opening }),
   escolher_pasta_padrao: shape({ kind: oneOf('escolher_pasta_padrao'), canonicalPath: text }),
+  configurar: shape({ kind: oneOf('configurar'), items: x => Array.isArray(x) && x.length > 0 && x.length <= 20 && x.every(shape({ status: oneOf('ok', 'erro', 'aviso'), item: x => text(x) && x.length <= 100, text: x => text(x) && x.length <= 600 })), restartRequired: bool }),
   atualizar_plugin: shape({ kind: oneOf('atualizar_plugin'), claude: plugin, codex: plugin, restartRequired: bool }),
   responder_sessao: shape({ kind: oneOf('responder_sessao'), turnStatus: oneOf('encerrado', 'cancelado', 'timeout', 'incerto'), resposta: optional(x => typeof x === 'string' && x.length <= 4000), motivo: optional(oneOf('conversa_em_uso', 'editor_aberto', 'pasta_invalida', 'outro')) }),
   ler_historico: shape({ kind: oneOf('ler_historico'), count: x => uint(x) && x <= 30, partial: bool, digest }),

package/lib/computador-executor.mjs

@@ -6,13 +6,14 @@
  * F02/Windows/Codex continuam atrás de capabilities e das receitas injetadas A4.
  */
 import path from 'node:path';
+import { configurar } from './configurar.mjs';
 import { readFileSync } from 'node:fs';
 import { acquireInstanceLock } from './computador-estado.mjs';
 import { readUserJson } from './computador-identidade.mjs';
 import { createReplyAdapter } from './computador-resposta.mjs';
 
 const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url))).version;
-const ACTIONS = ['abrir_pasta', 'abrir_sessao', 'baixar_abrir', 'escolher_pasta_projeto', 'escolher_pasta_padrao', 'atualizar_plugin', 'responder_sessao', 'ler_historico'];
+const ACTIONS = ['abrir_pasta', 'abrir_sessao', 'baixar_abrir', 'escolher_pasta_projeto', 'escolher_pasta_padrao', 'atualizar_plugin', 'configurar', 'responder_sessao', 'ler_historico'];
 const OPENING = ['abrindo_pasta', 'aguardando_editor', 'abrindo_conversa'];
 const RETRIES = [2000, 5000, 15000, 30000, 60000, 120000];
 const CLAIM = 'ops.computerRequestActions.claim', REPORT = 'ops.computerRequestActions.report';
@@ -48,7 +49,7 @@ function errorType(e) {
   return 'outro';
 }
 
-export async function runComputer({ identity, portal, journal, paths, folders, editor, git, plugins, diagnostics, history, reply = createReplyAdapter(), clock = {}, signal }) {
+export async function runComputer({ identity, portal, journal, paths, folders, editor, git, plugins, diagnostics, history, configure = configurar, reply = createReplyAdapter(), clock = {}, signal }) {
   const now = clock.now?.bind(clock) ?? Date.now;
   const later = clock.setTimeout?.bind(clock) ?? setTimeout, cancel = clock.clearTimeout?.bind(clock) ?? clearTimeout;
   const random = clock.random?.bind(clock) ?? Math.random;
@@ -520,6 +521,21 @@ export async function runComputer({ identity, portal, journal, paths, folders, e
         }, () => ({ kind: 'concluir', privateResult: { kind: 'abrir_pasta' } }));
         return r;
       }
+      if (r.action === 'configurar') {
+        await phase('atualizando_plugin');
+        await effect('atualizando_plugin', () => configure(['--sim'], {
+          nonInteractive: true, signal: operationSignal, announce: () => {},
+        }), result => {
+          const short = (value, limit) => String(value ?? '').replace(/[\x00-\x1f\x7f]/g, ' ').trim().slice(0, limit);
+          const items = result.results.map(row => ({ status: row.ok === true ? 'ok' : row.ok === 'warn' ? 'aviso' : 'erro',
+            item: short(row.item, 100), text: short(row.message, 600) }));
+          const privateResult = { kind: 'configurar', items, restartRequired: result.restartRequired === true };
+          return items.some(row => row.status !== 'ok')
+            ? { kind: 'aguardar', choices: ['tentar_novamente', 'cancelar'], privateResult }
+            : { kind: 'concluir', privateResult };
+        });
+        return r;
+      }
       if (r.action === 'atualizar_plugin') {
         if (!capabilities.atualizarPlugin) throw fail('EDITOR_RECIPE_UNVERIFIED');
         await phase('atualizando_plugin');

package/lib/computador-plugin.mjs

@@ -7,14 +7,14 @@
  */
 import { spawn } from 'node:child_process';
 
-const PLUGIN = 'chatflux-app@chatflux-marketplace';
-const MARKETPLACE = 'chatflux-marketplace';
+export const PLUGIN = 'chatflux-app@chatflux-marketplace';
+export const MARKETPLACE = 'chatflux-marketplace';
 const MAC_BINARIES = { claude: '/opt/homebrew/bin/claude', codex: '/opt/homebrew/bin/codex' };
-const LIST = {
+export const LIST = {
   claude: ['plugin', 'list', '--json'],
   codex: ['plugin', 'list', '--marketplace', MARKETPLACE, '--json'],
 };
-const UPDATES = {
+export const UPDATES = {
   claude: [['plugin', 'marketplace', 'update', MARKETPLACE], ['plugin', 'update', PLUGIN]],
   codex: [['plugin', 'marketplace', 'upgrade', MARKETPLACE]],
 };
@@ -28,11 +28,13 @@ const failed = (pluginVersion = null, exitCode) => ({
 
 function dependencies(options, updating = false) {
   const allowed = ['signal', 'spawnImpl', 'platform', 'windowsAdapter', 'timeoutMs'];
-  if (updating) allowed.push('previousResults');
+  if (updating) allowed.push('previousResults', 'tools', 'marketplaceUpdated');
   if (!options || Object.keys(options).some(k => !allowed.includes(k))) throw new Error('Opções de plugin inválidas.');
   const { spawnImpl = spawn, platform = process.platform, timeoutMs = 120_000, windowsAdapter, signal } = options;
   if (typeof spawnImpl !== 'function' || (windowsAdapter !== undefined && typeof windowsAdapter !== 'function') ||
       !Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 120_000) throw new Error('Opções de plugin inválidas.');
+  if (updating && ['tools', 'marketplaceUpdated'].some(key => options[key] !== undefined &&
+      (!Array.isArray(options[key]) || options[key].some(tool => !['claude', 'codex'].includes(tool))))) throw new Error('Opções de plugin inválidas.');
   return { spawnImpl, platform, timeoutMs, windowsAdapter, signal };
 }
 
@@ -86,7 +88,7 @@ function run(tool, argv, deps, capture = false) {
   });
 }
 
-function installedVersion(tool, stdout) {
+export function installedVersion(tool, stdout) {
   try {
     const data = JSON.parse(stdout);
     const rows = tool === 'claude' ? data : data.installed;
@@ -111,7 +113,7 @@ export async function readPluginVersions(options = {}) {
   return { claudePluginVersion: claude.pluginVersion, codexPluginVersion: codex.pluginVersion };
 }
 
-async function update(tool, previous, deps) {
+async function update(tool, previous, deps, marketplaceUpdated = []) {
   // Só sucesso é terminal na retentativa. Projeção explícita descarta campos livres
   // mesmo se o journal antigo contiver dados além do protocolo B1.
   if (previous?.status === 'atualizado') return { status: 'atualizado', pluginVersion: version(previous.pluginVersion) };
@@ -119,6 +121,7 @@ async function update(tool, previous, deps) {
   if (before.missing) return { status: 'nao_instalado' };
   if (!before.ok || !before.pluginVersion) return failed(before.pluginVersion, before.exitCode);
   for (const argv of UPDATES[tool]) {
+    if (marketplaceUpdated.includes(tool) && argv[1] === 'marketplace') continue;
     const result = await run(tool, argv, deps);
     if (!result.ok) return failed(before.pluginVersion, result.exitCode);
   }
@@ -129,8 +132,9 @@ async function update(tool, previous, deps) {
 
 export async function updatePlugins(options = {}) {
   const deps = dependencies(options, true);
-  const claude = await update('claude', options.previousResults?.claude, deps);
-  const codex = await update('codex', options.previousResults?.codex, deps);
+  const tools = options.tools ?? ['claude', 'codex'];
+  const claude = tools.includes('claude') ? await update('claude', options.previousResults?.claude, deps, options.marketplaceUpdated) : { status: 'nao_instalado' };
+  const codex = tools.includes('codex') ? await update('codex', options.previousResults?.codex, deps, options.marketplaceUpdated) : { status: 'nao_instalado' };
   // Conservador mesmo em sucesso parcial: o comando pode ter alterado arquivos
   // antes da falha. Reinício é orientação; esta API não encerra editor/conversa.
   return { claude, codex, restartRequired: options.previousResults?.restartRequired === true || deps.updateSent === true || claude.status === 'atualizado' || codex.status === 'atualizado' };

package/lib/configurar.mjs

@@ -0,0 +1,326 @@
+/** Preparação pessoal com receita fixa, também usada pelo botão do portal. Efeitos só fora de --verificar. */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import http from 'node:http';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { lerToken, expiraEm } from './config.mjs';
+import { scopeDirectory } from './computador-identidade.mjs';
+import { LIST, UPDATES, MARKETPLACE, PLUGIN, installedVersion, updatePlugins } from './computador-plugin.mjs';
+
+const REPO = 'Chatflux-Infra-Tools/chatflux-agent-toolkit';
+const URL_GIT = `https://github.com/${REPO}.git`;
+const ENTRY = fileURLToPath(new URL('../bin/gestao.mjs', import.meta.url));
+const VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url))).version;
+// Mesmo predicado cached de computador-startup.mjs; aquele módulo não o exporta.
+const cached = value => /(?:^|[\\/])(?:_npx|_cacache)(?:[\\/]|$)/i.test(value);
+const names = { claude: 'Claude Code', codex: 'Codex' };
+const accessHelp = 'Confira seu acesso ao repositório privado Chatflux-Infra-Tools/chatflux-agent-toolkit no GitHub e a conexão; depois rode gestao configurar de novo.';
+
+async function ask(question) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  const input = createInterface({ input: process.stdin, output: process.stdout });
+  try { return /^(s|sim)$/i.test((await input.question(`${question} `)).trim()); }
+  finally { input.close(); }
+}
+
+export async function configurar(flags = [], options = {}) {
+  if (flags.some(flag => !['--sim', '--verificar'].includes(flag))) throw new Error('Use gestao configurar [--sim] [--verificar].');
+  const verify = flags.includes('--verificar'), yes = flags.includes('--sim');
+  const signal = options.signal;
+  signal?.throwIfAborted();
+  const platform = options.platform ?? process.platform;
+  if (!['darwin', 'win32'].includes(platform)) throw new Error('Configurar está disponível para Mac e Windows.');
+  const p = platform === 'win32' ? path.win32 : path.posix;
+  const fsImpl = options.fsImpl ?? fs, spawnImpl = options.spawnImpl ?? spawn;
+  const home = options.home ?? os.homedir(), env = options.env ?? process.env;
+  const environment = env.GESTAO_ENV === 'dev' ? 'dev' : 'prod';
+  const commandEnv = { ...env, GESTAO_ENV: environment };
+  const nodePath = options.nodePath ?? process.execPath, entryPath = fsImpl.realpathSync(options.entryPath ?? ENTRY);
+  const version = options.version ?? VERSION, now = options.now ?? Date.now;
+  const announce = options.announce ?? console.log, confirm = options.confirm ?? ask;
+  const readToken = options.readToken ?? lerToken;
+  const results = [];
+  let restart = false;
+  function result(item, ok, message) {
+    signal?.throwIfAborted();
+    const line = `${item}: ${message} ${ok === 'warn' ? '⚠' : ok ? '✓' : '✗'}`;
+    results.push({ item, ok, message }); announce(line);
+  }
+  function read(file) {
+    try { return fsImpl.readFileSync(file, 'utf8'); }
+    catch (e) { if (e.code === 'ENOENT') return null; throw e; }
+  }
+  const json = file => { const text = read(file); return text === null ? null : JSON.parse(text); };
+  function resolveCommand(tool) {
+    const directories = [...new Set([...(env.PATH ?? env.Path ?? '').split(platform === 'win32' ? ';' : ':'),
+      p.dirname(nodePath), p.join(home, '.local/bin'), ...(platform === 'darwin' ? ['/opt/homebrew/bin', '/usr/local/bin'] : [])])].filter(Boolean);
+    for (const directory of directories) {
+      for (const ext of platform === 'win32' ? ['.exe', '.cmd'] : ['']) {
+        const binary = p.join(directory, `${tool}${ext}`);
+        try {
+          fsImpl.accessSync(binary, platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
+          if (!fsImpl.statSync(binary).isFile()) continue;
+          if (ext !== '.cmd') return { binary, prefix: [] };
+          // npm gera .cmd que não são executáveis via execFile. Rodar seu JS com
+          // o Node evita shell, aspas e expansão de %/& em caminhos do Windows.
+          const script = p.join(directory, 'node_modules', { npm: 'npm/bin/npm-cli.js', codex: '@openai/codex/bin/codex.js', claude: '@anthropic-ai/claude-code/cli.js' }[tool]);
+          if (fsImpl.existsSync(script)) return { binary: nodePath, prefix: [script] };
+        } catch (e) { if (!['ENOENT', 'EACCES'].includes(e.code)) throw e; }
+      }
+    }
+    return null;
+  }
+  const commands = {};
+  function start(command, argv, spawnOptions = {}) {
+    signal?.throwIfAborted();
+    if (!command) throw new Error('Programa não encontrado.');
+    return spawnImpl(command.binary, [...command.prefix, ...argv], { ...spawnOptions, ...(command.cwd ? { cwd: command.cwd } : {}), env: commandEnv, shell: false, windowsHide: true });
+  }
+  async function run(command, argv, interactive = false) {
+    return new Promise((resolve, reject) => {
+      let child, timer, bytes = 0, stdout = '', stderr = '', done = false;
+      const finish = (error, value) => { if (done) return; done = true; clearTimeout(timer); signal?.removeEventListener('abort', abort); error ? reject(error) : resolve(value); };
+      const abort = () => { try { child?.kill('SIGKILL'); } catch { /* somente filho próprio */ } finish(signal.reason ?? new Error('Cancelado.')); };
+      const stop = () => { try { child?.kill('SIGKILL'); } catch { /* somente filho próprio */ } finish(new Error('O comando demorou demais; tente novamente.')); };
+      try {
+        child = start(command, argv, { stdio: interactive && !options.nonInteractive ? 'inherit' : ['ignore', 'pipe', 'pipe'] });
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted) { abort(); return; }
+        for (const stream of ['stdout', 'stderr']) child[stream]?.on('data', chunk => {
+          bytes += Buffer.byteLength(chunk); if (bytes > 1024 * 1024) return stop();
+          if (stream === 'stdout') stdout += chunk; else stderr += chunk;
+        });
+        child.once('error', error => finish(error));
+        child.once('close', code => code === 0 ? finish(null, stdout.trim()) : finish(Object.assign(new Error('Não foi possível concluir o comando.'), { permission: /EACCES|EPERM|permission denied/i.test(stderr) })));
+        timer = setTimeout(stop, interactive ? 5 * 60_000 : 120_000);
+      } catch (error) { finish(error); }
+    });
+  }
+
+  announce(`Conferindo este computador · ambiente ${environment}${verify ? ' · somente diagnóstico' : ''}.`);
+  // Nada instala startup ou abre login com o ENTRY efêmero do npx.
+  let persistent = entryPath;
+  if (verify) {
+    try {
+      commands.npm = resolveCommand('npm');
+      const root = await run(commands.npm, ['root', '-g']);
+      if (!p.isAbsolute(root)) throw new Error('Pasta global inválida.');
+      const installed = json(p.join(root, 'chatflux-gestao-agente/package.json'))?.version;
+      let latest = null;
+      try { latest = await run(commands.npm, ['view', 'chatflux-gestao-agente', 'version']); } catch { /* sem registro */ }
+      const valid = v => typeof v === 'string' && /^\d+\.\d+\.\d+$/.test(v);
+      if (!valid(installed)) result('Programa do portal', false, 'instalação permanente não encontrada');
+      else if (!valid(latest)) result('Programa do portal', 'warn', `${installed}; versão do npm não confirmada`);
+      else if (installed !== latest) result('Programa do portal', false, `${installed} → ${latest} disponível`);
+      else result('Programa do portal', true, installed);
+    } catch { result('Programa do portal', 'warn', 'instalação permanente não confirmada'); }
+  } else if (cached(entryPath)) {
+    persistent = null;
+    try {
+      commands.npm = resolveCommand('npm');
+      await run(commands.npm, ['install', '-g', `chatflux-gestao-agente@${version}`]);
+      const root = await run(commands.npm, ['root', '-g']);
+      if (!p.isAbsolute(root)) throw new Error('Pasta global inválida.');
+      const candidate = fsImpl.realpathSync(p.join(root, 'chatflux-gestao-agente/bin/gestao.mjs'));
+      if (cached(candidate) || !fsImpl.statSync(candidate).isFile() || json(p.join(root, 'chatflux-gestao-agente/package.json'))?.version !== version) throw new Error('Instalação permanente não confirmada.');
+      persistent = candidate;
+      result('Programa do portal instalado', true, version);
+    } catch (error) {
+      const permission = error.permission || ['EACCES', 'EPERM'].includes(error.code);
+      result('Programa do portal instalado', false, permission
+        ? 'Sem permissão para instalar. Configure o npm/Node em uma pasta do seu usuário e repita gestao configurar, sem sudo nem administrador.'
+        : 'Instalação não confirmada. Confira o npm e a conexão; repita gestao configurar.');
+    }
+  } else result('Programa do portal instalado', true, version);
+
+  for (const tool of ['claude', 'codex']) {
+    try { commands[tool] = resolveCommand(tool); result(names[tool], true, commands[tool] ? 'instalado' : 'não instalado; etapa pulada'); }
+    catch { result(names[tool], false, 'não foi possível localizar o programa'); }
+  }
+  function source(tool) {
+    if (tool === 'claude') {
+      const data = json(p.join(home, '.claude/plugins/known_marketplaces.json'));
+      const entry = data?.[MARKETPLACE];
+      return { exists: !!entry, official: entry?.source?.source === 'github' && entry.source.repo === REPO };
+    }
+    const text = read(p.join(env.CODEX_HOME ?? p.join(home, '.codex'), 'config.toml')) ?? '';
+    let inside = false, exists = false;
+    const values = {};
+    for (const line of text.split(/\r?\n/)) {
+      const section = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/);
+      if (section) {
+        inside = /^marketplaces\.(?:chatflux-marketplace|"chatflux-marketplace"|'chatflux-marketplace')$/.test(section[1].trim());
+        if (inside) { if (exists) throw new Error('Loja duplicada no Codex.'); exists = true; }
+      } else if (inside && /^\s*source(?:_type)?\s*=/.test(line)) {
+        const field = line.match(/^\s*(source_type|source)\s*=\s*("(?:[^"\\]|\\.)*"|'[^']*')\s*(?:#.*)?$/);
+        if (!field || Object.hasOwn(values, field[1])) throw new Error('Fonte do Codex não reconhecida.');
+        values[field[1]] = field[2][0] === '"' ? JSON.parse(field[2]) : field[2].slice(1, -1);
+      }
+    }
+    return { exists, official: values.source_type === 'git' && values.source === URL_GIT };
+  }
+  const snapshots = {}, ready = [];
+  for (const tool of ['claude', 'codex']) {
+    if (!commands[tool]) continue;
+    try {
+      const store = source(tool);
+      if (verify) {
+        result(`${names[tool]} — loja de plugins`, store.official, store.official ? 'fonte oficial; pode atualizar' : 'falta trocar para a fonte oficial');
+        if (tool === 'claude') {
+          const installed = json(p.join(home, '.claude/plugins/installed_plugins.json'));
+          const rows = installed?.plugins?.[PLUGIN];
+          if (Array.isArray(rows)) snapshots[tool] = { version: installedVersion(tool, JSON.stringify(rows.map(row => ({ ...row, id: PLUGIN })))) };
+        } else try { snapshots[tool] = { version: installedVersion(tool, await run(commands[tool], LIST[tool])) }; } catch { /* versão desconhecida */ }
+        continue;
+      }
+      const output = await run(commands[tool], LIST[tool]);
+      const data = JSON.parse(output), rows = tool === 'claude' ? data : data.installed;
+      if (!Array.isArray(rows)) throw new Error('Lista de plugins não reconhecida.');
+      snapshots[tool] = { output, version: installedVersion(tool, output) };
+      const plugins = rows.filter(row => tool === 'claude' ? row?.id?.endsWith(`@${MARKETPLACE}`) : row?.installed === true && row.pluginId?.endsWith(`@${MARKETPLACE}`))
+        .map(row => ({ id: tool === 'claude' ? row.id : row.pluginId, scope: tool === 'claude' ? row.scope ?? 'user' : 'user', cwd: row.projectPath }));
+      if (!plugins.some(row => row.id === PLUGIN && row.scope === 'user')) plugins.push({ id: PLUGIN, scope: 'user' });
+      if (plugins.some(row => !/^[a-zA-Z0-9_-]+@chatflux-marketplace$/.test(row.id) || !['user', 'project', 'local'].includes(row.scope) || (row.scope !== 'user' && !p.isAbsolute(row.cwd ?? '')))) throw new Error('Não foi possível preservar os plugins instalados.');
+      if (!store.official) {
+        if (!yes && !await confirm('Trocar a loja de plugins para a oficial? (s/n)')) {
+          result(`${names[tool]} — loja de plugins`, false, 'troca não autorizada; repita no terminal ou use --sim para autorizar'); continue;
+        }
+        restart = true;
+        if (store.exists) await run(commands[tool], ['plugin', 'marketplace', 'remove', MARKETPLACE]);
+        await run(commands[tool], ['plugin', 'marketplace', 'add', tool === 'claude' ? REPO : URL_GIT]);
+      }
+      restart = true;
+      await run(commands[tool], UPDATES[tool][0]);
+      ready.push(tool);
+      const missingApp = !rows.some(row => tool === 'claude' ? row.id === PLUGIN && row.scope === 'user' : row.pluginId === PLUGIN && row.installed);
+      let restored = true;
+      for (const row of !store.official ? plugins : missingApp ? [{ id: PLUGIN, scope: 'user' }] : []) {
+        try {
+          // O escopo de projeto usa o diretório original, sem alterar o cwd do processo.
+          await run({ ...commands[tool], cwd: row.cwd }, tool === 'claude' ? ['plugin', 'install', row.id, '--scope', row.scope] : ['plugin', 'add', row.id]);
+        } catch { restored = false; }
+      }
+      result(`${names[tool]} — loja de plugins`, restored, restored ? 'fonte oficial atualizada; plugins preservados' : `fonte oficial atualizada; falta reinstalar um plugin. ${accessHelp}`);
+    } catch {
+      result(`${names[tool]} — loja de plugins`, false, `Não foi possível conferir ou atualizar a loja. ${accessHelp}`);
+    }
+  }
+  if (verify) {
+    let latest = null, origin = '';
+    try {
+      const data = readToken();
+      if (data?.env === environment && expiraEm(data.token) > now()) {
+        const host = environment === 'dev' ? 'https://agreeable-woodpecker-190.convex.cloud' : 'https://dependable-stingray-656.convex.cloud';
+        const response = await (options.fetchImpl ?? fetch)(`${host}/api/query`, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${data.token}` }, body: JSON.stringify({ path: 'ops/plugin:meuStatus', args: {}, format: 'json' }), signal: AbortSignal.timeout(10000) });
+        const body = await response.json();
+        if (response.ok && body.status === 'success') latest = body.value?.atual;
+      }
+    } catch { /* tenta loja local */ }
+    if (!/^\d+\.\d+\.\d+$/.test(latest ?? '')) {
+      try { latest = json(p.join(home, '.claude/plugins/marketplaces/chatflux-marketplace/plugins/chatflux-app/.claude-plugin/plugin.json'))?.version; origin = ' (versão da loja)'; } catch { /* indisponível */ }
+    }
+    if (!/^\d+\.\d+\.\d+$/.test(latest ?? '')) latest = null;
+    for (const tool of ['claude', 'codex']) if (commands[tool]) {
+      const installed = snapshots[tool]?.version;
+      if (!installed) result(`${names[tool]} — chatflux-app`, 'warn', `versão não confirmada${latest && origin ? `; versão da loja: ${latest}` : ''}`);
+      else if (!latest) result(`${names[tool]} — chatflux-app`, 'warn', `${installed}; versão atual não confirmada`);
+      else if (installed !== latest) result(`${names[tool]} — chatflux-app`, false, `${installed} → atual ${latest}${origin} (vai atualizar)`);
+      else result(`${names[tool]} — chatflux-app`, true, `${installed}${origin}`);
+    }
+  } else {
+    const bridge = (tool, argv, spawnOptions) => start(commands[tool], argv, spawnOptions);
+    const updated = await updatePlugins({ platform, signal, tools: ready, marketplaceUpdated: ready,
+      ...(platform === 'win32' ? { windowsAdapter: bridge } : { spawnImpl: (binary, argv, spawnOptions) => bridge(binary.endsWith('/claude') ? 'claude' : 'codex', argv, spawnOptions) }) });
+    restart ||= updated.restartRequired;
+    for (const tool of ['claude', 'codex']) if (commands[tool]) {
+      const item = updated[tool], ok = ready.includes(tool) && item.status === 'atualizado';
+      result(`${names[tool]} — chatflux-app`, ok, ok ? item.pluginVersion : `atualização não confirmada${item.pluginVersion ? `; versão ${item.pluginVersion}` : ''}. ${accessHelp}`);
+    }
+  }
+
+  const credential = () => { const value = readToken(); return value?.env === environment ? value : null; };
+  const expiry = value => value?.token ? expiraEm(value.token) : 0;
+  const until = value => new Date(expiry(value)).toLocaleString('pt-BR');
+  let loginOk = false;
+  try {
+    let data = credential();
+    if (expiry(data) - now() <= 15 * 86400000) {
+      if (verify) result('Login do portal', false, 'ausente, vencido ou vence em até 15 dias; precisa renovar no navegador');
+      else if (!persistent) result('Login do portal', false, 'pulado; instale o programa do portal em uma pasta permanente');
+      else {
+        await run({ binary: nodePath, prefix: [persistent] }, ['login'], true);
+        data = credential(); loginOk = expiry(data) > now();
+        result('Login do portal', loginOk, loginOk ? `conectado até ${until(data)}` : 'login não confirmado; rode gestao login');
+      }
+    } else { loginOk = true; result('Login do portal', true, `válido até ${until(data)}`); }
+  } catch { result('Login do portal', false, 'não foi possível conectar; rode gestao login e autorize no navegador'); }
+
+  // statusComputer protege arquivos e openJournal cria diretórios. O diagnóstico
+  // usa apenas um retrato dos metadados, sem ACL, journal aberto ou canal local.
+  function readOnlyComputer() {
+    const baseDir = p.join(home, '.config/gestao/computadores');
+    const active = json(p.join(baseDir, environment, 'ativo.json'));
+    if (!active?.subject) return { computerId: null, startupInstalled: false, startupHealthy: false };
+    const directory = p.join(baseDir, environment, p.basename(scopeDirectory({ env: environment, subject: active.subject })));
+    const identity = json(p.join(directory, 'identidade.json'));
+    const journal = json(p.join(directory, 'journal.json'));
+    const startupRoot = platform === 'darwin' ? p.join(home, '.config/gestao/startup') : p.join(env.LOCALAPPDATA || home, 'ChatFluxGestao/startup');
+    const config = json(p.join(startupRoot, environment, 'startup.json'));
+    const launcher = platform === 'darwin'
+      ? p.join(home, 'Library/LaunchAgents', `ai.chatflux.gestao-computador.${environment}.plist`)
+      : p.join(startupRoot, environment, 'launcher.vbs');
+    const configured = !!config && config.env === environment && config.platform === platform && fsImpl.existsSync(launcher) &&
+      [config.nodePath, config.entryPath, config.identityPath].every(file => typeof file === 'string' && !cached(file) && fsImpl.existsSync(file));
+    return { directory, computerId: identity?.computerId, startupInstalled: configured, startupHealthy: configured,
+      state: journal?.stopped ? 'desligado' : 'configurado; execução não conferida' };
+  }
+  async function checkResident(directory) {
+    const file = p.join(directory, 'controle.json');
+    let stat;
+    try { stat = fsImpl.lstatSync(file); } catch (e) { if (e.code === 'ENOENT') return null; throw e; }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > 8192) throw new Error('Controle inválido.');
+    const data = json(file);
+    if (data?.version !== 1 || !Number.isSafeInteger(data.port) || data.port < 1 || data.port > 65535 || !Number.isSafeInteger(data.pid) || data.pid < 1 || !/^[a-f0-9]{64}$/.test(data.key)) throw new Error('Controle inválido.');
+    return new Promise((resolve, reject) => {
+      const req = http.request({ host: '127.0.0.1', port: data.port, path: '/status', method: 'POST', headers: { Authorization: `Bearer ${data.key}` }, timeout: 3000, agent: false }, res => {
+        let body = ''; res.setEncoding('utf8');
+        res.on('data', chunk => { body += chunk; if (body.length > 8192) req.destroy(); });
+        res.on('end', () => { try { if (res.statusCode !== 200) throw new Error(); resolve(JSON.parse(body)); } catch { reject(new Error('Controle indisponível.')); } });
+      });
+      req.on('timeout', () => req.destroy()); req.on('error', reject); req.end();
+    });
+  }
+  try {
+    const status = verify ? (options.readOnlyComputer ?? readOnlyComputer)() : await (options.statusComputer ?? (await import('./computador-cli.mjs')).statusComputer)();
+    if (verify && status.computerId && status.startupInstalled && status.startupHealthy && status.state !== 'desligado') {
+      let live;
+      try { live = await (options.checkResident ?? checkResident)(status.directory); }
+      catch { live = undefined; }
+      if (live?.state) result('Computador', ['conectado', 'residente iniciado'].includes(live.state) ? true : 'warn', `residente em execução; ${live.state}`);
+      else if (live === null) result('Computador', false, 'configurado; residente não está rodando');
+      else result('Computador', 'warn', 'configurado; não deu para conferir se está rodando');
+    } else {
+    const connected = !!status.computerId && status.startupInstalled && status.startupHealthy &&
+      ['conectado', 'residente iniciado'].includes(status.state);
+    if (connected) result('Computador', true, verify ? status.state : 'já registrado e ligado');
+    else if (verify) result('Computador', false, 'precisa registrar ou ligar; rode gestao configurar');
+    else if (!persistent || !loginOk) result('Computador', false, 'etapa pulada; conclua a instalação e o login, depois repita gestao configurar');
+    else {
+      await run({ binary: nodePath, prefix: [persistent] }, ['ligar'], true);
+      result('Computador', true, 'registrado e ligado');
+    }
+    }
+  } catch { result('Computador', false, 'não foi possível conferir ou ligar; rode gestao ligar e siga a orientação exibida'); }
+  const pending = results.filter(item => item.ok !== true);
+  if (!pending.length) announce('\nTudo pronto neste computador ✓');
+  else {
+    announce('\nResumo:');
+    for (const item of pending) announce(`${item.item}: ${item.message} ${item.ok === 'warn' ? '⚠' : '✗'}`);
+  }
+  if (restart) announce('Para terminar: reinicie o VS Code e abra uma nova conversa no Claude Code/Codex.');
+  if (verify && pending.length) announce('Para resolver, rode: npx -y chatflux-gestao-agente@latest configurar');
+  return { results, restartRequired: restart };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatflux-gestao-agente",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "description": "Opere o portal Gestão da ChatFlux pelo Claude Code, Claude Desktop ou qualquer harness MCP — com a sua identidade e o seu papel.",
   "keywords": [