sijur-cli 2.0.0

package/README.md

@@ -0,0 +1,138 @@
+# sijur — CLI
+
+Espelho de linha de comando das ferramentas MCP do SIJUR. Cada ferramenta da MCP e um comando
+aqui, com o mesmo nome e os mesmos parametros.
+
+A CLI **nao decide nada**. Ela autentica, converte os argumentos conforme o schema que a propria
+MCP publica, chama a ferramenta e imprime o que voltou. Nao tem regra de negocio, nao le nem
+escreve arquivo seu, nao compoe chamadas. Ferramenta nova na MCP aparece aqui sozinha; parametro
+que mudar de tipo passa a ser convertido pelo tipo novo — nao ha lista de comandos para manter
+sincronizada.
+
+## Instalacao
+
+Precisa de Node.js 18 ou mais novo (`node -v`).
+
+### Para quem vai usar
+
+```bash
+npm install -g sijur-cli
+sijur login
+```
+
+> Enquanto o pacote nao estiver publicado no npm, use um dos caminhos abaixo.
+
+### Publicar no npm (uma vez, por quem mantem)
+
+```bash
+cd cli
+npm login                 # conta com direito de publicar o nome `sijur-cli`
+npm publish --access public
+```
+
+O pacote nao carrega segredo nenhum: a credencial de cada pessoa e obtida no `sijur login` e fica
+no Keychain da maquina dela. Publicar e so distribuir o cliente.
+
+### Sem publicar — tarball servido pelo proprio SIJUR
+
+```bash
+cd cli && npm pack                    # gera sijur-cli-2.0.0.tgz
+# suba o .tgz para um endereco que os usuarios alcancem, e entao, na maquina de cada um:
+npm install -g https://sijur.com.br/downloads/sijur-cli-2.0.0.tgz
+```
+
+### Sem publicar — a partir do repositorio
+
+```bash
+git clone git@github.com:grgbrasil/sijur_2025.git
+cd sijur_2025/cli && npm install --omit=dev && npm pack
+npm install -g ./sijur-cli-2.0.0.tgz
+```
+
+Confira com `sijur --help`. Desinstalar: `npm uninstall -g sijur-cli`.
+
+## Sessao
+
+```bash
+sijur login       # abre o navegador; autorize com a sua conta
+sijur whoami      # escopos, validade e ferramentas visiveis
+```
+
+OAuth 2.1 com PKCE. O refresh token fica no **Keychain do macOS** (servico `sijur-cli`); fora do
+macOS, em `~/.sijur-cli/credentials.json` com permissao `600`.
+
+**Escopos:** a CLI pede todos os que o servidor anuncia em `scopes_supported` — hoje 26 — e a tela
+de consentimento mostra uma caixa por escopo, todas marcadas. Quem decide o que entra e voce, ali:
+desmarcar um escopo tira do token as ferramentas daquele dominio, e o `sijur tools` passa a nao
+lista-las. Nao ha lista de escopos no codigo da CLI; escopo novo no servidor aparece sozinho.
+
+### Trocar de escritorio
+
+**O token e por escritorio**, e o escritorio se escolhe na tela de autorizacao. `sijur login` com
+credencial ainda valida **nao passa por ela** — renova em silencio e voce continua no escritorio
+anterior (o comando avisa quando isso acontece). Para trocar:
+
+```bash
+sijur login --trocar
+```
+
+Derrubar so esta maquina: `sijur logout --revogar`.
+
+## Uso
+
+```bash
+sijur tools                       # o que este token enxerga
+sijur tools tarefas_encerrar      # parametros, tipos e descricao
+sijur <ferramenta> [--param valor ...]
+```
+
+O catalogo vem filtrado por escopo pelo proprio servidor: `sijur tools` lista exatamente o que
+este token pode chamar.
+
+### Argumentos
+
+Convertidos pelo schema da ferramenta, nunca por adivinhacao — por isso `--tarefa_id 123456` vira
+numero e `--processo_numero 1234567-89.2024.4.04.7100` continua texto.
+
+| tipo no schema | como se escreve |
+|---|---|
+| `string` | `--relatorio "Protocolado RExt"` |
+| `number` | `--tarefa_id 123456` |
+| `boolean` | `--dry_run` (verdadeiro) ou `--dry_run false` |
+| `array` | `--fechar_pendencias tarefa:123400,tarefa_prazo:123401` ou JSON `'["a","b"]'` |
+| `object` | JSON: `--filtros '[{"campo":"x","operador":"=","valor":"y"}]'` |
+
+Parametro que a ferramenta nao tem e erro, com a lista dos validos. Obrigatorio faltando tambem.
+
+### Saida
+
+O objeto que a ferramenta devolveu, identado. Com `--json`, numa linha so.
+
+| codigo | significado |
+|---|---|
+| 0 | ok |
+| 1 | erro de uso (parametro invalido, obrigatorio faltando, ferramenta fora do escopo) |
+| 2 | autenticacao: sem token, expirado, escopo insuficiente |
+| 4 | erro da ferramenta ou da rede |
+
+## Exemplos
+
+```bash
+sijur prazos_do_processo --processo_numero 1234567-89.2024.4.04.7100
+sijur prazos_do_processo --processo_numero 7654321-12.2023.4.04.7112 --incluir_fechados
+sijur tarefas_momentos_listar --processo_id 33418
+sijur tarefas_encerrar --tarefa_id 123456 --relatorio "Protocolado RExt" \
+  --fechar_pendencias tarefa:123400,tarefa_prazo:123401 \
+  --fechar_ns_entidade_pai --momento_processual 46 --dry_run
+```
+
+## Auditoria
+
+Toda chamada apenda uma linha em `~/.sijur-cli/audit.jsonl`: timestamp, ferramenta, argumentos e
+se deu certo.
+
+## Variaveis de ambiente
+
+| variavel | padrao |
+|---|---|
+| `SIJUR_MCP_URL` | `https://sijur.com.br/mcp` |

package/bin/sijur.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import { EXIT, CliError, erroUso } from '../src/exit.js';
+import { fechar } from '../src/mcp.js';
+
+const AJUDA = `sijur — espelho de linha de comando das ferramentas MCP do SIJUR
+
+Cada ferramenta da MCP e um comando aqui, com os mesmos nomes e os mesmos
+parametros. A CLI nao decide nada por conta propria: ela autentica, converte os
+argumentos conforme o schema da ferramenta, chama, e imprime o que voltou.
+
+USO
+  sijur <ferramenta> [--parametro valor ...]   chama a ferramenta
+  sijur tools                                  lista o que este token enxerga
+  sijur tools <ferramenta>                     parametros e descricao dela
+
+SESSAO
+  sijur login [--trocar]     autoriza esta maquina. --trocar forca a tela de novo,
+                             que e o unico jeito de mudar de escritorio
+  sijur logout [--revogar]   apaga a credencial local; --revogar derruba no servidor
+  sijur whoami               escopos, validade e ferramentas visiveis
+
+GLOBAIS
+  --json          imprime numa linha so (o padrao e identado)
+  -h, --help      esta ajuda
+
+CODIGOS DE SAIDA
+  0 ok   1 erro de uso   2 autenticacao/escopo   4 erro da ferramenta ou da rede
+
+EXEMPLOS
+  sijur tools
+  sijur tools tarefas_encerrar
+  sijur prazos_do_processo --processo_numero 1234567-89.2024.4.04.7100
+  sijur tarefas_encerrar --tarefa_id 123456 --relatorio "Protocolado RExt" --dry_run
+`;
+
+const GLOBAIS = new Set(['--json', '--help', '-h', '--trocar', '--revogar']);
+const SESSAO = new Set(['login', 'logout', 'whoami', 'tools']);
+
+// Sem lista fixa de parametros: o schema da ferramenta e que manda. Aqui so separamos
+// `--chave valor` de `--flag`, e a coercao acontece depois, contra o schema.
+function parsear(argv) {
+  const globais = {};
+  const params = {};
+  const soltos = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (GLOBAIS.has(a)) { globais[a] = true; continue; }
+    if (a.startsWith('--')) {
+      const chave = a.slice(2);
+      if (!chave) throw erroUso('`--` sozinho nao e parametro.');
+      const proximo = argv[i + 1];
+      if (proximo === undefined || proximo.startsWith('--')) params[chave] = true;
+      else { params[chave] = proximo; i++; }
+      continue;
+    }
+    if (a.startsWith('-')) throw erroUso(`Opcao desconhecida: ${a}`);
+    soltos.push(a);
+  }
+  return { globais, params, soltos };
+}
+
+async function principal() {
+  const { globais, params, soltos } = parsear(process.argv.slice(2));
+  const comando = soltos[0];
+  const op = { json: !!globais['--json'] };
+
+  if (globais['-h'] || globais['--help'] || !comando) {
+    process.stdout.write(AJUDA);
+    return EXIT.OK;
+  }
+
+  if (SESSAO.has(comando)) {
+    const s = await import('../src/cmds/sessao.js');
+    if (comando === 'login')  return s.cmdLogin({ ...op, trocar: !!globais['--trocar'] });
+    if (comando === 'logout') return s.cmdLogout({ ...op, revogar: !!globais['--revogar'] });
+    if (comando === 'whoami') return s.cmdWhoami(op);
+    return (await import('../src/cmds/tools.js')).cmdTools(soltos[1], op);
+  }
+
+  if (soltos.length > 1) {
+    throw erroUso(`So uma ferramenta por invocacao (recebi "${soltos.join('", "')}"). ` +
+      `Valores com espaco vao entre aspas.`);
+  }
+
+  return (await import('../src/cmds/chamar.js')).cmdChamar(comando, params, op);
+}
+
+principal()
+  .then(async code => { await fechar(); process.exit(code ?? EXIT.OK); })
+  .catch(async err => {
+    await fechar().catch(() => {});
+    const code = err instanceof CliError ? err.code : EXIT.API;
+    if (process.argv.includes('--json')) {
+      process.stdout.write(JSON.stringify({ ok: false, erro: err.message, exit: code }) + '\n');
+    } else {
+      process.stderr.write(`ERRO (${code}): ${err.message}\n`);
+    }
+    process.exit(code);
+  });

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "sijur-cli",
+  "version": "2.0.0",
+  "type": "module",
+  "description": "Espelho de linha de comando das ferramentas MCP do SIJUR — um comando por ferramenta, sem regra propria",
+  "bin": {
+    "sijur": "bin/sijur.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "license": "UNLICENSED",
+  "author": "SIJUR"
+}

package/src/audit.js

@@ -0,0 +1,13 @@
+import fs from 'node:fs';
+import { AUDIT_PATH, garantirHome } from './config.js';
+
+// Append-only. Toda escrita passa por aqui, inclusive a que falhou.
+export function auditar(registro) {
+  try {
+    garantirHome();
+    const linha = JSON.stringify({ ts: new Date().toISOString(), ...registro });
+    fs.appendFileSync(AUDIT_PATH, linha + '\n', { mode: 0o600 });
+  } catch (err) {
+    process.stderr.write(`[audit] falhou ao gravar: ${err.message}\n`);
+  }
+}

package/src/auth.js

@@ -0,0 +1,202 @@
+import http from 'node:http';
+import net from 'node:net';
+import crypto from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { auth } from '@modelcontextprotocol/sdk/client/auth.js';
+import { SERVIDOR, escoposSuportados } from './config.js';
+import * as cofre from './keychain.js';
+import { erroAuth } from './exit.js';
+
+const PORTAS = [53682, 53683, 53684, 53685, 53686];
+const REDIRECTS = PORTAS.map(p => `http://127.0.0.1:${p}/callback`);
+
+function portaLivre(porta) {
+  return new Promise(resolve => {
+    const s = net.createServer();
+    s.once('error', () => resolve(false));
+    s.once('listening', () => s.close(() => resolve(true)));
+    s.listen(porta, '127.0.0.1');
+  });
+}
+
+async function escolherPorta() {
+  for (const p of PORTAS) {
+    if (await portaLivre(p)) return p;
+  }
+  throw erroAuth(`Nenhuma porta livre em ${PORTAS.join(', ')} para receber o retorno do login.`);
+}
+
+function abrirNavegador(url) {
+  const cmd = process.platform === 'darwin' ? 'open'
+    : process.platform === 'win32' ? 'cmd'
+    : 'xdg-open';
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+  execFile(cmd, args, () => { /* se falhar, o usuario abre a URL na mao */ });
+}
+
+class ProvedorSijur {
+  constructor(porta, escopos = []) {
+    this._redirect = `http://127.0.0.1:${porta}/callback`;
+    this._urlAutorizacao = null;
+    this._escopos = escopos;
+  }
+
+  get redirectUrl() { return this._redirect; }
+
+  get clientMetadata() {
+    return {
+      client_name: 'SIJUR CLI',
+      redirect_uris: REDIRECTS,
+      grant_types: ['authorization_code', 'refresh_token'],
+      response_types: ['code'],
+      token_endpoint_auth_method: 'none',
+      scope: (this._escopos || []).join(' ')
+    };
+  }
+
+  state() {
+    const s = crypto.randomBytes(16).toString('base64url');
+    this._state = s;
+    return s;
+  }
+
+  clientInformation() { return cofre.ler()?.client; }
+  saveClientInformation(info) { cofre.atualizar({ client: info }); }
+
+  tokens() { return cofre.ler()?.tokens; }
+  saveTokens(t) {
+    cofre.atualizar({
+      tokens: t,
+      obtido_em: new Date().toISOString(),
+      expira_em: t.expires_in ? new Date(Date.now() + t.expires_in * 1000).toISOString() : null
+    });
+  }
+
+  redirectToAuthorization(url) { this._urlAutorizacao = url; }
+
+  saveCodeVerifier(v) { cofre.atualizar({ code_verifier: v }); }
+  codeVerifier() {
+    const v = cofre.ler()?.code_verifier;
+    if (!v) throw erroAuth('Verificador PKCE ausente. Rode `sijur login` de novo.');
+    return v;
+  }
+
+  invalidateCredentials(escopo) {
+    if (escopo === 'all') return cofre.apagar();
+    const atual = cofre.ler() || {};
+    if (escopo === 'tokens') delete atual.tokens;
+    if (escopo === 'client') delete atual.client;
+    if (escopo === 'verifier') delete atual.code_verifier;
+    cofre.gravar(atual);
+  }
+}
+
+// Recebe UMA requisicao no loopback e devolve o code.
+function esperarRetorno(porta, estadoEsperado, timeoutMs = 300000) {
+  return new Promise((resolve, reject) => {
+    const servidor = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://127.0.0.1:${porta}`);
+      if (url.pathname !== '/callback') {
+        res.writeHead(404).end();
+        return;
+      }
+      const code = url.searchParams.get('code');
+      const erro = url.searchParams.get('error');
+      const estado = url.searchParams.get('state');
+      const responder = (titulo, corpo) => {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(`<!doctype html><meta charset="utf-8"><title>${titulo}</title>
+<body style="font-family:system-ui;padding:48px;text-align:center">
+<h2>${titulo}</h2><p>${corpo}</p></body>`);
+      };
+
+      if (erro) {
+        responder('Autorizacao negada', 'Pode fechar esta aba e voltar ao terminal.');
+        encerrar();
+        reject(erroAuth(`Autorizacao negada pelo servidor: ${erro}`));
+        return;
+      }
+      if (estadoEsperado && estado !== estadoEsperado) {
+        responder('Estado invalido', 'O parametro state nao confere. Login abortado.');
+        encerrar();
+        reject(erroAuth('Parametro `state` divergente — possivel CSRF. Login abortado.'));
+        return;
+      }
+      if (!code) {
+        responder('Retorno sem codigo', 'Pode fechar esta aba e voltar ao terminal.');
+        encerrar();
+        reject(erroAuth('O servidor voltou sem `code`.'));
+        return;
+      }
+      responder('SIJUR CLI autorizado', 'Pode fechar esta aba e voltar ao terminal.');
+      encerrar();
+      resolve(code);
+    });
+
+    const relogio = setTimeout(() => {
+      encerrar();
+      reject(erroAuth('Tempo esgotado esperando a autorizacao no navegador (5 min).'));
+    }, timeoutMs);
+
+    function encerrar() {
+      clearTimeout(relogio);
+      servidor.close();
+    }
+
+    servidor.on('error', err => { encerrar(); reject(erroAuth(`Falha no servidor local: ${err.message}`)); });
+    servidor.listen(porta, '127.0.0.1');
+  });
+}
+
+export async function fazerLogin({ trocar = false, escrever = s => process.stderr.write(s) } = {}) {
+  const porta = await escolherPorta();
+  const escopos = await escoposSuportados();
+  const p = new ProvedorSijur(porta, escopos);
+
+  // WHY `--trocar`: com token valido no cofre, `auth()` devolve AUTHORIZED sem passar pela tela.
+  // Isso e correto para renovar, e ARMADILHA para trocar de escritorio — o token e por escritorio,
+  // e quem roda `login` de novo esperando trocar continua no anterior sem nenhum sinal. Descartar o
+  // token (mantendo o registro do cliente) forca a tela, que e onde o escritorio se escolhe.
+  if (trocar) {
+    const atual = cofre.ler() || {};
+    delete atual.tokens;
+    delete atual.code_verifier;
+    cofre.gravar(atual);
+  }
+
+  const r = await auth(p, { serverUrl: SERVIDOR, scope: escopos.join(' ') });
+  if (r === 'AUTHORIZED') return { ja_autorizado: true, escopos_pedidos: escopos };
+  if (!p._urlAutorizacao) throw erroAuth('O SDK nao produziu URL de autorizacao.');
+
+  const espera = esperarRetorno(porta, p._state);
+  escrever(`Abrindo o navegador para autorizar.\nSe nao abrir, acesse:\n${p._urlAutorizacao}\n\n`);
+  abrirNavegador(p._urlAutorizacao.toString());
+
+  const code = await espera;
+  const r2 = await auth(p, { serverUrl: SERVIDOR, authorizationCode: code, scope: escopos.join(' ') });
+  if (r2 !== 'AUTHORIZED') throw erroAuth(`Troca do codigo falhou (${r2}).`);
+  return { ja_autorizado: false, escopos_pedidos: escopos };
+}
+
+export function provedorParaTransporte() {
+  return new ProvedorSijur(PORTAS[0]);
+}
+
+export async function revogar() {
+  const blob = cofre.ler();
+  if (!blob?.tokens?.refresh_token) return { revogado: false, motivo: 'sem_token' };
+  const meta = await fetch(new URL('/.well-known/oauth-authorization-server', SERVIDOR).toString())
+    .then(r => r.json()).catch(() => null);
+  const endpoint = meta?.revocation_endpoint;
+  if (!endpoint) return { revogado: false, motivo: 'sem_endpoint' };
+  const corpo = new URLSearchParams({
+    token: blob.tokens.refresh_token,
+    client_id: blob.client?.client_id || ''
+  });
+  const res = await fetch(endpoint, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: corpo
+  });
+  return { revogado: res.ok, status: res.status };
+}

package/src/cmds/chamar.js

@@ -0,0 +1,85 @@
+import { chamarBruto, listarToolsCompleto } from '../mcp.js';
+import { EXIT, erroUso } from '../exit.js';
+import { auditar } from '../audit.js';
+
+function tiposDe(prop) {
+  if (prop?.type) return Array.isArray(prop.type) ? prop.type : [prop.type];
+  if (Array.isArray(prop?.anyOf)) return prop.anyOf.flatMap(x => (x.type ? [x.type] : []));
+  return [];
+}
+
+// Converte o texto do terminal para o tipo que o schema da tool pede.
+// WHY pelo schema e nao por heuristica: `--tarefa_id 123456` tem de virar number, e
+// `--processo_numero 1234567-89...` tem de continuar string. So o schema sabe a diferenca.
+export function coagir(valor, prop, chave) {
+  const tipos = tiposDe(prop);
+
+  if (tipos.includes('boolean') && tipos.length === 1) {
+    if (valor === true || valor === 'true' || valor === '1') return true;
+    if (valor === 'false' || valor === '0') return false;
+    throw erroUso(`--${chave} e booleano: use --${chave} (verdadeiro) ou --${chave} false.`);
+  }
+  if (valor === true) {
+    // flag sem valor num parametro nao-booleano
+    if (tipos.includes('boolean')) return true;
+    throw erroUso(`--${chave} precisa de um valor.`);
+  }
+
+  const texto = String(valor);
+
+  if (tipos.includes('number') || tipos.includes('integer')) {
+    if (tipos.length === 1) {
+      const n = Number(texto);
+      if (!Number.isFinite(n)) throw erroUso(`--${chave} espera numero, recebeu "${texto}".`);
+      return n;
+    }
+  }
+  if (tipos.includes('array') || tipos.includes('object')) {
+    const t = texto.trim();
+    if (t.startsWith('[') || t.startsWith('{')) {
+      try { return JSON.parse(t); } catch { throw erroUso(`--${chave}: JSON invalido — ${t.slice(0, 60)}`); }
+    }
+    if (tipos.includes('array')) return texto.split(',').map(x => x.trim()).filter(Boolean);
+  }
+  if (tipos.includes('string')) return texto;
+
+  // anyOf/sem tipo: aceita JSON quando parecer JSON, senao texto
+  const t = texto.trim();
+  if (t.startsWith('[') || t.startsWith('{')) { try { return JSON.parse(t); } catch { /* texto mesmo */ } }
+  if (/^-?\d+(\.\d+)?$/.test(t)) return Number(t);
+  if (t === 'true') return true;
+  if (t === 'false') return false;
+  return texto;
+}
+
+export async function cmdChamar(nome, brutos, op) {
+  const tools = await listarToolsCompleto();
+  const tool = tools.find(t => t.name === nome);
+  if (!tool) {
+    throw erroUso(`Ferramenta "${nome}" nao existe ou nao esta no escopo deste token. Rode \`sijur tools\`.`);
+  }
+
+  const props = tool.inputSchema?.properties || {};
+  const argumentos = {};
+  for (const [chave, valor] of Object.entries(brutos)) {
+    if (!(chave in props)) {
+      const validos = Object.keys(props).map(k => `--${k}`).join(' ') || '(nenhum)';
+      throw erroUso(`--${chave} nao e parametro de ${nome}. Validos: ${validos}`);
+    }
+    argumentos[chave] = coagir(valor, props[chave], chave);
+  }
+
+  const faltando = (tool.inputSchema?.required || []).filter(k => !(k in argumentos));
+  if (faltando.length) {
+    throw erroUso(`${nome} exige ${faltando.map(k => `--${k}`).join(', ')}. Detalhe: sijur tools ${nome}`);
+  }
+
+  const resultado = await chamarBruto(nome, argumentos);
+
+  process.stdout.write(op.json
+    ? JSON.stringify(resultado) + '\n'
+    : JSON.stringify(resultado, null, 2) + '\n');
+
+  auditar({ comando: nome, argumentos, ok: resultado?.success !== false });
+  return resultado?.success === false ? EXIT.API : EXIT.OK;
+}

package/src/cmds/sessao.js

@@ -0,0 +1,79 @@
+import { fazerLogin, revogar } from '../auth.js';
+import * as cofre from '../keychain.js';
+import { SERVIDOR, escoposSuportados } from '../config.js';
+import { listarTools, fechar } from '../mcp.js';
+
+import { EXIT, erroAuth } from '../exit.js';
+
+
+function emitir(obj, op) {
+  process.stdout.write(op.json ? JSON.stringify(obj) + '\n' : JSON.stringify(obj, null, 2) + '\n');
+}
+
+export async function cmdLogin(op) {
+  const r = await fazerLogin({ trocar: op.trocar });
+  const blob = cofre.ler();
+  const avisos = [];
+  if (r.ja_autorizado) {
+    avisos.push('Ja havia credencial valida — NAO passei pela tela de autorizacao, ' +
+      'entao o escritorio continua o mesmo de antes. Para trocar de escritorio: `sijur login --trocar`.');
+  }
+  emitir({
+    ok: true,
+    servidor: SERVIDOR,
+    ja_estava_autorizado: r.ja_autorizado,
+    autorizou_agora: !r.ja_autorizado,
+    escopos_pedidos: r.escopos_pedidos || [],
+    escopos_concedidos: (blob?.tokens?.scope || '').split(' ').filter(Boolean),
+    guardado_em: cofre.ondeGuarda,
+    expira_em: blob?.expira_em || null,
+    avisos
+  }, op);
+  return EXIT.OK;
+}
+
+export async function cmdLogout(op) {
+  let revogado = { revogado: false, motivo: 'nao_pedido' };
+  if (op.revogar) revogado = await revogar();
+  cofre.apagar();
+  emitir({ ok: true, credenciais_apagadas: true, revogado_no_servidor: revogado.revogado, detalhe: revogado }, op);
+  return EXIT.OK;
+}
+
+export async function cmdWhoami(op) {
+  const blob = cofre.ler();
+  if (!blob?.tokens?.access_token) throw erroAuth('Sem credencial nesta maquina. Rode `sijur login`.');
+
+  const concedidos = (blob.tokens.scope || '').split(' ').filter(Boolean);
+  // WHY nao tratar escopo nao-concedido como erro: desmarcar caixa no consentimento e decisao
+  // legitima do dono. O que a CLI mostra e o que ele concedeu e o que isso da de ferramenta.
+  const suportados = await escoposSuportados().catch(() => []);
+  const naoConcedidos = suportados.filter(e => !concedidos.includes(e));
+
+  let tools = null;
+  let vivo = false;
+  try {
+    tools = await listarTools();
+    vivo = true;
+  } catch (err) {
+    tools = `nao consegui listar: ${err.message}`;
+  } finally {
+    await fechar();
+  }
+
+  emitir({
+    ok: vivo,
+    servidor: SERVIDOR,
+    cliente: blob.client?.client_id || null,
+    guardado_em: cofre.ondeGuarda,
+    obtido_em: blob.obtido_em || null,
+    expira_em: blob.expira_em || null,
+    escopos_concedidos: concedidos,
+    escopos_nao_concedidos: naoConcedidos,
+    sessao_viva: vivo,
+    total_ferramentas: Array.isArray(tools) ? tools.length : null,
+    tools_visiveis: tools
+  }, op);
+
+  return vivo ? EXIT.OK : EXIT.AUTH;
+}

package/src/cmds/tools.js

@@ -0,0 +1,60 @@
+import { listarToolsCompleto } from '../mcp.js';
+import { EXIT, erroUso } from '../exit.js';
+
+function tiposDe(prop) {
+  if (prop?.type) return Array.isArray(prop.type) ? prop.type : [prop.type];
+  if (Array.isArray(prop?.anyOf)) return prop.anyOf.flatMap(x => x.type ? [x.type] : []);
+  return [];
+}
+
+export async function cmdTools(nome, op) {
+  const tools = await listarToolsCompleto();
+
+  if (!nome) {
+    if (op.json) {
+      process.stdout.write(JSON.stringify({ ok: true, total: tools.length, tools: tools.map(t => ({ nome: t.name, descricao: t.description })) }) + '\n');
+      return EXIT.OK;
+    }
+    process.stdout.write(`${tools.length} ferramentas visiveis para este token:\n\n`);
+    for (const t of tools) {
+      const primeira = String(t.description || '').split(/(?<=\.)\s/)[0];
+      process.stdout.write(`  ${t.name.padEnd(30)} ${primeira.slice(0, 90)}\n`);
+    }
+    process.stdout.write(`\nDetalhe de uma: sijur tools <nome>\n`);
+    return EXIT.OK;
+  }
+
+  const t = tools.find(x => x.name === nome);
+  if (!t) throw erroUso(`Ferramenta "${nome}" nao existe ou nao esta no escopo deste token. Rode \`sijur tools\`.`);
+
+  if (op.json) {
+    process.stdout.write(JSON.stringify({ ok: true, nome: t.name, descricao: t.description, schema: t.inputSchema }) + '\n');
+    return EXIT.OK;
+  }
+
+  const props = t.inputSchema?.properties || {};
+  const obrig = new Set(t.inputSchema?.required || []);
+  process.stdout.write(`${t.name}\n\n${t.description || '(sem descricao)'}\n\nParametros:\n`);
+  if (!Object.keys(props).length) process.stdout.write('  (nenhum)\n');
+  for (const [k, v] of Object.entries(props)) {
+    const tipos = tiposDe(v).join('|') || 'qualquer';
+    const marca = obrig.has(k) ? ' (obrigatorio)' : '';
+    process.stdout.write(`  --${k} <${tipos}>${marca}\n`);
+    if (v.description) {
+      for (const linha of quebrar(String(v.description), 84)) process.stdout.write(`      ${linha}\n`);
+    }
+  }
+  process.stdout.write(`\nExemplo: sijur ${t.name}${Object.keys(props).slice(0, 2).map(k => ` --${k} <valor>`).join('')}\n`);
+  return EXIT.OK;
+}
+
+function quebrar(txt, largura) {
+  const out = [];
+  let linha = '';
+  for (const p of txt.split(/\s+/)) {
+    if ((linha + ' ' + p).trim().length > largura) { out.push(linha.trim()); linha = p; }
+    else linha += ' ' + p;
+  }
+  if (linha.trim()) out.push(linha.trim());
+  return out;
+}

package/src/config.js

@@ -0,0 +1,51 @@
+import { homedir } from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+
+export const SERVIDOR = process.env.SIJUR_MCP_URL || 'https://sijur.com.br/mcp';
+
+// WHY descobrir em vez de listar: a CLI e espelho. Escopo novo no servidor tem de aparecer no
+// consentimento sozinho — lista fixa aqui significaria uma ferramenta nova invisivel ate alguem
+// lembrar de editar este arquivo. `scopes_supported` e o que o proprio servidor anuncia como
+// concedivel (ele ja remove os `extension:*`, que nao valem para cliente OAuth).
+// Quem decide o que ENTRA e o dono, na tela de consentimento, marcando as caixas.
+const ESCOPOS_RESERVA = ['service:pendencias', 'service:pendencias:write'];
+let _escopos = null;
+
+export async function escoposSuportados() {
+  if (_escopos) return _escopos;
+  try {
+    const meta = await fetch(new URL('/.well-known/oauth-protected-resource', SERVIDOR).toString())
+      .then(r => (r.ok ? r.json() : null));
+    const lista = meta?.scopes_supported;
+    if (Array.isArray(lista) && lista.length) {
+      _escopos = lista;
+      return _escopos;
+    }
+  } catch { /* offline ou servidor antigo: cai na reserva */ }
+  _escopos = ESCOPOS_RESERVA;
+  return _escopos;
+}
+
+// WHY `.sijur-cli` e nao `.sijur`: `~/.sijur/` ja e o diretorio de runtime da automacao do
+// SIJUR nesta maquina (esteira, followup-fila, plan-exec, debt-drain — logs e launchers vivos).
+// A spec pedia `~/.sijur/audit.jsonl` pela razao certa (ficar FORA da pasta do lote, que o agente
+// le); um diretorio proprio cumpre isso sem disputar espaco com outro sistema.
+export const HOME_SIJUR = path.join(homedir(), '.sijur-cli');
+export const AUDIT_PATH = path.join(HOME_SIJUR, 'audit.jsonl');
+export const STATE_PATH = path.join(HOME_SIJUR, 'state.json');
+
+export function garantirHome() {
+  fs.mkdirSync(HOME_SIJUR, { recursive: true, mode: 0o700 });
+  return HOME_SIJUR;
+}
+
+// O lote e o diretorio que contem MANIFESTO_PECAS.csv. Ordem: --lote, SIJUR_LOTE, cwd.
+export function resolverLote(flagLote) {
+  const cand = flagLote || process.env.SIJUR_LOTE || process.cwd();
+  return path.resolve(cand);
+}
+
+export const ARQ_MANIFESTO = 'MANIFESTO_PECAS.csv';
+export const ARQ_CONTROLE = 'PROTOCOLADOS.md';
+export const DIR_PROTOCOLADO = '01_JA_PROTOCOLADO';

package/src/exit.js

@@ -0,0 +1,18 @@
+export const EXIT = {
+  OK: 0,
+  USO: 1,
+  AUTH: 2,
+  API: 4
+};
+
+export class CliError extends Error {
+  constructor(code, message, extra = {}) {
+    super(message);
+    this.code = code;
+    this.extra = extra;
+  }
+}
+
+export const erroUso = (m, e) => new CliError(EXIT.USO, m, e);
+export const erroAuth = (m, e) => new CliError(EXIT.AUTH, m, e);
+export const erroApi = (m, e) => new CliError(EXIT.API, m, e);

package/src/keychain.js

@@ -0,0 +1,75 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { HOME_SIJUR, SERVIDOR, garantirHome } from './config.js';
+
+const SERVICO = 'sijur-cli';
+const CONTA = new URL(SERVIDOR).host;
+const NO_MAC = process.platform === 'darwin';
+const ARQ_FALLBACK = path.join(HOME_SIJUR, 'credentials.json');
+
+function lerKeychain() {
+  try {
+    const out = execFileSync('security',
+      ['find-generic-password', '-a', CONTA, '-s', SERVICO, '-w'],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return JSON.parse(out.trim());
+  } catch {
+    return null;
+  }
+}
+
+function gravarKeychain(blob) {
+  execFileSync('security',
+    ['add-generic-password', '-a', CONTA, '-s', SERVICO, '-U',
+     '-D', 'sijur-cli credentials', '-w', JSON.stringify(blob)],
+    { stdio: ['ignore', 'ignore', 'pipe'] });
+}
+
+function apagarKeychain() {
+  try {
+    execFileSync('security', ['delete-generic-password', '-a', CONTA, '-s', SERVICO],
+      { stdio: 'ignore' });
+  } catch { /* nao existia */ }
+}
+
+function lerArquivo() {
+  try {
+    return JSON.parse(fs.readFileSync(ARQ_FALLBACK, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function gravarArquivo(blob) {
+  garantirHome();
+  fs.writeFileSync(ARQ_FALLBACK, JSON.stringify(blob, null, 2), { mode: 0o600 });
+  fs.chmodSync(ARQ_FALLBACK, 0o600);
+}
+
+function apagarArquivo() {
+  try { fs.unlinkSync(ARQ_FALLBACK); } catch { /* nao existia */ }
+}
+
+export function ler() {
+  return NO_MAC ? lerKeychain() : lerArquivo();
+}
+
+export function gravar(blob) {
+  return NO_MAC ? gravarKeychain(blob) : gravarArquivo(blob);
+}
+
+export function apagar() {
+  return NO_MAC ? apagarKeychain() : apagarArquivo();
+}
+
+export function atualizar(patch) {
+  const atual = ler() || {};
+  const novo = { ...atual, ...patch };
+  gravar(novo);
+  return novo;
+}
+
+export const ondeGuarda = NO_MAC
+  ? `Keychain do macOS (servico "${SERVICO}", conta "${CONTA}")`
+  : ARQ_FALLBACK;

package/src/mcp.js

@@ -0,0 +1,180 @@
+import { auth } from '@modelcontextprotocol/sdk/client/auth.js';
+import { SERVIDOR } from './config.js';
+import { provedorParaTransporte } from './auth.js';
+import * as cofre from './keychain.js';
+import { erroAuth, erroApi } from './exit.js';
+
+// WHY cliente proprio em vez do StreamableHTTPClientTransport do SDK:
+// o transporte do SDK abre, logo apos o handshake, um GET de longa duracao para o canal
+// servidor->cliente. Sob HTTP/1.1 esse GET fica ocupando a conexao e o POST seguinte espera
+// atras dele — medido: `tools/call` com o stream aberto nao responde em 12s; o MESMO POST, sem
+// o stream, responde em ~240ms. A CLI e pedido-resposta pura: nao consome notificacao do
+// servidor, entao o canal so tinha custo. Sem ele, some a classe inteira de timeout.
+// O SDK continua sendo a fonte do OAuth (`auth`), que e onde ele e solido.
+
+const PROTOCOLO = '2025-06-18';
+let _sessao = null;
+let _proximoId = 1;
+
+function tokenGuardado() {
+  return cofre.ler()?.tokens?.access_token || null;
+}
+
+function cabecalhos(token, sessao) {
+  return {
+    'Authorization': `Bearer ${token}`,
+    'Content-Type': 'application/json',
+    'Accept': 'application/json, text/event-stream',
+    'MCP-Protocol-Version': PROTOCOLO,
+    ...(sessao ? { 'mcp-session-id': sessao } : {})
+  };
+}
+
+// A resposta vem como um frame SSE (`event: message` + `data: {...}`) ou como JSON puro.
+function extrairEnvelope(texto, id) {
+  const bruto = texto.trim();
+  if (!bruto) return null;
+  if (bruto.startsWith('{')) {
+    try { return JSON.parse(bruto); } catch { return null; }
+  }
+  for (const linha of bruto.split('\n')) {
+    if (!linha.startsWith('data:')) continue;
+    try {
+      const obj = JSON.parse(linha.slice(5).trim());
+      if (obj.id === id || id === undefined) return obj;
+    } catch { /* frame parcial */ }
+  }
+  return null;
+}
+
+async function renovarToken() {
+  const p = provedorParaTransporte();
+  const r = await auth(p, { serverUrl: SERVIDOR });
+  if (r !== 'AUTHORIZED') throw erroAuth('Token expirado e nao consegui renovar. Rode `sijur login`.');
+  const t = tokenGuardado();
+  if (!t) throw erroAuth('Renovacao nao devolveu token. Rode `sijur login`.');
+  return t;
+}
+
+async function postar(corpo, { token, sessao }) {
+  return fetch(SERVIDOR, { method: 'POST', headers: cabecalhos(token, sessao), body: JSON.stringify(corpo) });
+}
+
+// Uma tentativa; devolve { resposta, token } ja com renovacao feita se tomou 401.
+async function postarComRenovacao(corpo, sessao) {
+  let token = tokenGuardado();
+  if (!token) throw erroAuth('Sem credencial nesta maquina. Rode `sijur login`.');
+  let r = await postar(corpo, { token, sessao });
+  if (r.status === 401) {
+    token = await renovarToken();
+    r = await postar(corpo, { token, sessao });
+    if (r.status === 401) throw erroAuth('Token recusado pelo servidor. Rode `sijur login`.');
+  }
+  return { resposta: r, token };
+}
+
+export async function conectar() {
+  if (_sessao) return _sessao;
+
+  const id = _proximoId++;
+  const { resposta } = await postarComRenovacao({
+    jsonrpc: '2.0', id, method: 'initialize',
+    params: { protocolVersion: PROTOCOLO, capabilities: {}, clientInfo: { name: 'sijur-cli', version: '1.0.0' } }
+  }, null);
+
+  if (!resposta.ok) {
+    throw erroApi(`Handshake recusado por ${SERVIDOR}: HTTP ${resposta.status}`);
+  }
+  const sessao = resposta.headers.get('mcp-session-id');
+  const env = extrairEnvelope(await resposta.text(), id);
+  if (env?.error) throw erroApi(`Handshake: ${env.error.message || JSON.stringify(env.error)}`);
+  if (!sessao) throw erroApi('Servidor nao devolveu mcp-session-id no handshake.');
+
+  _sessao = sessao;
+  // Notificacao obrigatoria do protocolo; nao tem resposta.
+  await postarComRenovacao({ jsonrpc: '2.0', method: 'notifications/initialized' }, _sessao).catch(() => {});
+  return _sessao;
+}
+
+export async function fechar() {
+  _sessao = null;
+}
+
+const RE_SCOPE = /Scope insuficiente\.?\s*Requer:\s*([^\s"'}]+)/i;
+
+function checarEscopo(texto) {
+  const m = RE_SCOPE.exec(texto || '');
+  if (m) throw erroAuth(`Escopo faltando: ${m[1]}. Rode \`sijur login\` para reautorizar com esse escopo.`);
+}
+
+export const chamarBruto = (nome, argumentos) => _chamar(nome, argumentos, true);
+export const chamar = (nome, argumentos) => _chamar(nome, argumentos, false);
+
+async function _chamar(nome, argumentos, bruto) {
+  const sessao = await conectar();
+  const id = _proximoId++;
+
+  const { resposta } = await postarComRenovacao({
+    jsonrpc: '2.0', id, method: 'tools/call', params: { name: nome, arguments: argumentos }
+  }, sessao);
+
+  if (resposta.status === 429) {
+    throw erroApi(`Limite de requisicoes do SIJUR atingido (HTTP 429). Espere e repita.`);
+  }
+  const texto = await resposta.text();
+  if (!resposta.ok) {
+    checarEscopo(texto);
+    throw erroApi(`Tool ${nome}: HTTP ${resposta.status} — ${texto.slice(0, 300)}`);
+  }
+
+  const env = extrairEnvelope(texto, id);
+  if (!env) throw erroApi(`Tool ${nome}: nao entendi a resposta do servidor: ${texto.slice(0, 200)}`);
+  if (env.error) {
+    checarEscopo(env.error.message || '');
+    throw erroApi(`Tool ${nome}: ${env.error.message || JSON.stringify(env.error)}`);
+  }
+
+  const conteudo = (env.result?.content || []).filter(c => c.type === 'text').map(c => c.text).join('\n');
+  checarEscopo(conteudo);
+
+  if (env.result?.structuredContent && typeof env.result.structuredContent === 'object') {
+    return env.result.structuredContent;
+  }
+  if (!conteudo) throw erroApi(`Tool ${nome} devolveu resposta vazia.`);
+
+  let obj;
+  try {
+    obj = JSON.parse(conteudo);
+  } catch {
+    if (env.result?.isError) throw erroApi(`Tool ${nome}: ${conteudo.slice(0, 400)}`);
+    throw erroApi(`Tool ${nome} devolveu texto que nao e JSON: ${conteudo.slice(0, 200)}`);
+  }
+
+  if (bruto) return obj;
+
+  if (env.result?.isError || obj?.success === false) {
+    throw erroApi(`Tool ${nome}: ${obj?.error || obj?.motivo || conteudo.slice(0, 300)}`, { resposta: obj });
+  }
+  return obj;
+}
+
+// O servidor ja filtra o catalogo por escopo do token — o que volta aqui e exatamente
+// o que este token pode chamar. E a fonte do espelho: nomes, descricoes e schemas.
+let _catalogo = null;
+
+export async function listarToolsCompleto() {
+  if (_catalogo) return _catalogo;
+  const sessao = await conectar();
+  const id = _proximoId++;
+  const { resposta } = await postarComRenovacao({ jsonrpc: '2.0', id, method: 'tools/list', params: {} }, sessao);
+  const texto = await resposta.text();
+  if (!resposta.ok) throw erroApi(`tools/list: HTTP ${resposta.status}`);
+  const env = extrairEnvelope(texto, id);
+  if (env?.error) throw erroApi(`tools/list: ${env.error.message}`);
+  _catalogo = (env?.result?.tools || []).slice().sort((a, b) => a.name.localeCompare(b.name));
+  return _catalogo;
+}
+
+export async function listarTools() {
+  return (await listarToolsCompleto()).map(t => t.name);
+}