chatflux-gestao-agente 0.2.1 → 0.2.3

package/README.md

@@ -11,12 +11,30 @@ faz na tela, e tudo no histórico com o seu nome.
 ## 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)
 
@@ -50,7 +68,7 @@ gestao login
   └─ guarda no Keychain (macOS) ou em ~/.config/gestao/token.json (0600)
 ```
 
-Vale **até 6 horas** (a validade real aparece no login e no `gestao status`). E na prática você não faz nada disso à mão: o próprio agente
+Vale **1 ano** (decisão de 10/11; a validade real aparece no login e no `gestao status`). E na prática você não faz nada disso à mão: o próprio agente
 chama a tool `gestao_conectar` quando precisa, o navegador abre, você clica em
 **Autorizar** e ele refaz a ação. O `gestao login` no terminal existe como
 alternativa, não como o caminho normal.
@@ -143,7 +161,7 @@ continuam disponíveis; não contam como prova da abertura assistida.
 
 ### Reconectar, trocar ambiente ou conta
 
-O login vence (normalmente até 6 h). O residente pausa os pedidos e orienta
+O login vence (1 ano desde o último `gestao login`). O residente pausa os pedidos e orienta
 `gestao login` ou `gestao_conectar`; ele não renova o token silenciosamente.
 `gestao status` mostra ambiente, startup, computador e a causa local mesmo sem
 rede/login. O indicador do portal pode levar até 180 s para perder a conexão.

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-cli.mjs

@@ -257,6 +257,7 @@ export function createComputerCli(options = {}) {
         const state = await startup.installStartup(startupOptions);
         if (!state.installed || !state.healthy) throw fail('Startup não confirmado.');
         await startResident(identity);
+        if (state.correctedEntryPath) announce('Caminho do início automático corrigido.');
       } catch {
         journal.transition({ kind: 'stop', computerId: identity.computerId, generation: registration.generation });
         let rollbackFailed = false;

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/computador-startup.mjs

@@ -116,7 +116,16 @@ export function createStartupManager({
     const content = read(l.path);
     const entry = l.platform === 'darwin' ? content !== null : win().get(l.name) !== null;
     if (entry && !c) throw conflict();
-    if (c && l.platform === 'darwin' && content && content.toString() !== plist(l, c)) throw conflict();
+    if (c && l.platform === 'darwin' && content && content.toString() !== plist(l, c)) {
+      try {
+        const parsed = JSON.parse(command('/usr/bin/plutil', ['-convert', 'json', '-o', '-', l.path]));
+        const args = parsed.ProgramArguments;
+        if (parsed.Label !== l.label || !Array.isArray(args) || args.length !== 4 ||
+          typeof args[1] !== 'string' || !args[1].endsWith('/bin/gestao.mjs') ||
+          args[2] !== 'computador' || args[3] !== 'executar' || parsed.EnvironmentVariables?.GESTAO_ENV !== l.env) throw conflict();
+        return true;
+      } catch { throw conflict(); }
+    }
     if (c && l.platform === 'win32') {
       const value = win().get(l.name);
       if (value !== null && value !== c.command) throw conflict();
@@ -155,7 +164,7 @@ export function createStartupManager({
     const c = { version: 1, env: l.env, platform: l.platform, nodePath: validateFile(options.nodePath, l.platform), entryPath: validateFile(options.entryPath, l.platform), identityPath: validateFile(options.identityPath, l.platform), command: null };
     ensureUserDirectory(l.root, protect); ensureUserDirectory(l.directory, protect);
     return withFileGate(l.directory, () => {
-      const previous = metadata(l); owned(l, previous);
+      const previous = metadata(l), changedPlist = owned(l, previous);
       const files = [l.path, l.configPath, ...(l.platform === 'win32' ? [l.launchConfig] : [])];
       const backup = files.map(file => [file, read(file)]);
       const oldService = l.platform === 'darwin' ? serviceState(l) : null;
@@ -172,7 +181,7 @@ export function createStartupManager({
           c.command = `${quoteWindows(path.win32.join(windowsDirectory || 'C:\\Windows', 'System32/wscript.exe'))} //B //Nologo ${quoteWindows(launcher)}`;
           if (c.command.length > 260) throw failure();
         }
-        if (JSON.stringify(previous) === JSON.stringify(c) && startupStatus(options).healthy && (l.platform === 'win32' || wasRunning)) return startupStatus(options);
+        if (!changedPlist && JSON.stringify(previous) === JSON.stringify(c) && startupStatus(options).healthy && (l.platform === 'win32' || wasRunning)) return startupStatus(options);
         touched = true;
         if (l.platform === 'darwin') {
           fs.mkdirSync(path.dirname(l.path), { recursive: true });
@@ -187,7 +196,7 @@ export function createStartupManager({
           if (win().get(l.name) !== c.command) throw failure();
         }
         write(l.configPath, JSON.stringify(c));
-        return startupStatus(options);
+        return { ...startupStatus(options), correctedEntryPath: l.platform === 'darwin' && !!previous && (changedPlist || previous.entryPath !== c.entryPath || previous.nodePath !== c.nodePath) };
       } catch {
         if (touched) {
           try {

package/lib/config.mjs

@@ -39,7 +39,7 @@ export function ambiente() {
 //
 // Keychain do macOS quando houver (é onde o SO já guarda segredo e o usuário
 // controla o acesso); arquivo 0600 como fallback nos outros sistemas. O token
-// vale até 6h (template `convex-agente`) — por isso não fica em texto puro no
+// vale 1 ano (template `convex-agente`) — por isso não fica em texto puro no
 // macOS, que é a máquina real da equipe. Revogação antes do `exp`: arquivar a
 // conta (`active:false`); `gestao logout` só apaga a cópia local.
 
@@ -113,6 +113,12 @@ export function descreverValidade(jwt, agora = Date.now()) {
   const exp = expiraEm(jwt);
   const restaMin = Math.max(0, Math.round((exp - agora) / 60000));
   if (!exp || restaMin === 0) return "validade desconhecida";
+  // Acima de um dia, hora sem data engana ("87599h59 (até 18:40)"): mostra dias e data.
+  if (restaMin > 24 * 60) {
+    const dias = Math.floor(restaMin / (24 * 60));
+    const data = new Date(exp).toLocaleDateString("pt-BR", { day: "2-digit", month: "2-digit", year: "numeric" });
+    return `${dias} dia${dias === 1 ? "" : "s"} (até ${data})`;
+  }
   const h = Math.floor(restaMin / 60);
   const m = restaMin % 60;
   const dur = h === 0 ? `${m} min` : m === 0 ? `${h}h` : `${h}h${String(m).padStart(2, "0")}`;
@@ -120,6 +126,20 @@ export function descreverValidade(jwt, agora = Date.now()) {
   return `${dur} (até ${hora})`;
 }
 
+/** Aviso para o modelo repassar à pessoa quando faltam 15 dias ou menos para o
+ *  login vencer. Com validade de 1 ano, sem isso o vencimento pega de surpresa.
+ *  "" fora da janela, com token inválido ou já vencido (aí a chamada falha e o
+ *  modelo chama `gestao_conectar` por conta própria). */
+export function avisoVencimento(jwt, agora = Date.now()) {
+  const exp = expiraEm(jwt);
+  if (!exp || exp <= agora || exp - agora > 15 * 86_400_000) return "";
+  return (
+    `AVISO: o login do Gestão desta máquina vence em ${descreverValidade(jwt, agora)}. ` +
+    "Diga isso à pessoa em uma frase e ofereça renovar agora com a tool `gestao_conectar` " +
+    "(abre o navegador; vale mais 1 ano)."
+  );
+}
+
 export function tokenValido(dados, margemMs = 60_000) {
   return Boolean(dados?.token) && expiraEm(dados.token) - margemMs > Date.now();
 }

package/lib/configurar.mjs

@@ -0,0 +1,319 @@
+/** Preparação pessoal, sem comandos recebidos 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 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) {
+    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 = {}) {
+    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); error ? reject(error) : resolve(value); };
+      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 ? 'inherit' : ['ignore', 'pipe', 'pipe'] });
+        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, 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/lib/gestao.mjs

@@ -73,7 +73,7 @@ let cache = null;
  * disco — é cache, não fonte: só serve pra listar tools quando a credencial
  * expirou, e qualquer chamada de verdade continua exigindo login.
  *
- * Isso existe porque o token vence (6h): sem o cache, a pessoa veria o servidor
+ * Isso existe porque o token vence (1 ano): sem o cache, a pessoa veria o servidor
  * MCP "falhar ao conectar" a cada expiração, sem pista do motivo.
  */
 export async function contrato({ permitirCache = false } = {}) {

package/lib/login.mjs

@@ -1,7 +1,7 @@
 // `gestao login` — o handshake de identidade.
 //
 // Sobe um listener em 127.0.0.1 numa porta efêmera, abre o portal com `port` e
-// `state`, e espera a página devolver o JWT do template `convex-agente` (6h). O browser já
+// `state`, e espera a página devolver o JWT do template `convex-agente` (1 ano). O browser já
 // tem a sessão do Clerk; nós nunca vemos senha, e o backend não ganha rota nova.
 //
 // Por que NÃO OAuth: o Clerk não documenta caminho de credencial OAuth → JWT com

package/lib/mcp.mjs

@@ -13,7 +13,7 @@ import path from "node:path";
 import { contrato, chamar, euSou } from "./gestao.mjs";
 import { loginVerificado } from "./login.mjs";
 import { nomeServico } from "./servico.mjs";
-import { ambiente, descreverValidade } from "./config.mjs";
+import { ambiente, avisoVencimento, descreverValidade, lerToken } from "./config.mjs";
 import { montarTools } from "./tools.mjs";
 
 const PROTOCOLO = "2024-11-05";
@@ -41,7 +41,7 @@ let tools = null;
 /**
  * A tool que CONECTA — não a que pede pra pessoa digitar comando.
  *
- * Fica SEMPRE na lista, autenticado ou não, porque a sessão vence (6h no
+ * Fica SEMPRE na lista, autenticado ou não, porque a sessão vence (1 ano no
  * template `convex-agente`): quando qualquer ação falhar por sessão, o modelo chama esta e a pessoa
  * só clica no navegador. Ela nunca precisa saber que existe uma CLI.
  */
@@ -49,7 +49,7 @@ const TOOL_CONECTAR = {
   name: "gestao_conectar",
   description:
     "Conecta esta máquina ao Gestão. ABRE O NAVEGADOR para a pessoa autorizar com " +
-    "o login dela (leva segundos) e vale algumas horas (6h no padrão).\n\n" +
+    "o login dela (leva segundos) e vale 1 ano.\n\n" +
     "CHAME ISTO SEM PEDIR PERMISSÃO sempre que uma ação do Gestão falhar por " +
     "sessão expirada ou ausente, ou quando não houver nenhuma outra tool do Gestão " +
     "disponível. Depois de conectar, refaça a ação que falhou.\n\n" +
@@ -60,6 +60,20 @@ const TOOL_CONECTAR = {
   _endpoint: null,
 };
 
+/** Uma vez por processo (= por sessão do harness), na primeira chamada que deu
+ *  certo: se o login vence em até 15 dias, devolve o aviso para ir junto da
+ *  resposta. Modo serviço não tem login de pessoa. */
+let vencimentoConferido = false;
+function conferirVencimento() {
+  if (vencimentoConferido || nomeServico()) return "";
+  vencimentoConferido = true;
+  try {
+    return avisoVencimento(lerToken()?.token);
+  } catch {
+    return "";
+  }
+}
+
 /** Estamos no estado degradado (só a tool de conectar)? */
 const soConectar = (t) => t?.length === 1 && t[0]._endpoint === null;
 
@@ -167,7 +181,10 @@ async function tratar(msg) {
     }
     try {
       const valor = await chamar(tool._endpoint, params.arguments ?? {}, tool._kind);
-      return ok(id, texto(valor ?? { ok: true }));
+      const resultado = texto(valor ?? { ok: true });
+      const aviso = conferirVencimento();
+      if (aviso) resultado.content.push({ type: "text", text: aviso });
+      return ok(id, resultado);
     } catch (e) {
       // Erro de REGRA (ex.: "Empresa arquivada…") volta como conteúdo, não como
       // erro de protocolo: é informação que o modelo deve ler e agir em cima.
@@ -179,7 +196,7 @@ async function tratar(msg) {
 }
 
 export async function servir() {
-  // NUNCA sai por falta de credencial. O token vence (6h); se o servidor morresse
+  // NUNCA sai por falta de credencial. O token vence (1 ano); se o servidor morresse
   // ao expirar, a pessoa veria "Failed to connect — Connection closed" a cada
   // expiração, sem pista do motivo. Aqui ele sobe sempre, e a falta de sessão
   // aparece como uma tool que EXPLICA o que fazer.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatflux-gestao-agente",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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": [