oficio-pro 0.0.0-stage → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/LICENSE ADDED
@@ -0,0 +1,23 @@
1
+ LICENÇA DE USO INDIVIDUAL — OFÍCIO PRO DA CODETRADE (ASSINATURA)
2
+
3
+ Copyright (c) 2026 CODETRADE INTELIGENCIA, SISTEMAS E TECNOLOGIA LTDA. Todos os direitos reservados.
4
+
5
+ 1. Licença. Ao assinar o Ofício Pro, e enquanto a assinatura estiver ativa, você (pessoa física ou um único profissional) recebe uma licença pessoal, não exclusiva e intransferível para instalar e usar o Ofício Pro nos seus próprios computadores, para uso pessoal ou no seu próprio trabalho.
6
+
7
+ 2. O que você pode. Instalar em quantos computadores seus quiser; adaptar os textos das skills para o seu próprio uso; usar os resultados (propostas, posts, planos e demais textos gerados) livremente, inclusive com seus clientes.
8
+
9
+ 3. O que você não pode. Compartilhar, revender, sublicenciar, publicar ou distribuir o .zip, a sua chave de acesso, os arquivos, o conteúdo recebido do servidor ou versões modificadas, no todo ou em parte, gratuitamente ou não; disponibilizar o conteúdo em repositório público, grupo, curso ou área de membros; usar o conteúdo para criar produto concorrente.
10
+
11
+ 4. Equipes. Uso por mais de uma pessoa exige uma licença por pessoa ou acordo por escrito com a Codetrade.
12
+
13
+ 5. Componentes de terceiros. Partes adaptadas de projetos de código aberto continuam sob as licenças originais, listadas em CREDITOS.md, que prevalecem sobre esta licença no que se refere a essas partes.
14
+
15
+ 6. Sem garantia. O Ofício Pro é fornecido "no estado em que se encontra". Ele organiza informações e prepara rascunhos; não substitui médico, psicólogo, nutricionista, advogado, contador ou consultor de investimentos. A Codetrade não se responsabiliza por decisões tomadas com base nos textos gerados.
16
+
17
+ 6-A. Acesso pelo servidor e chave. O conteúdo completo das skills e agentes é entregue pelo servidor do Ofício Pro mediante uma chave pessoal e intransferível. O acesso termina na hora em caso de cancelamento da assinatura, reembolso ou contestação do pagamento; em caso de pagamento atrasado, continua por até 10 dias. Uso da mesma chave por várias pessoas pode levar ao bloqueio da chave.
18
+
19
+ 7. Encerramento. O descumprimento desta licença a encerra automaticamente, sem prejuízo das medidas cabíveis.
20
+
21
+ 8. Lei e foro. Esta licença segue as leis brasileiras. Fica eleito o foro da comarca de Campo Grande/MS, ressalvado o direito do consumidor de propor ação no foro do seu domicílio.
22
+
23
+ Contato: contato@codetrade.me
package/README.md CHANGED
@@ -1,3 +1,27 @@
1
- # Temporary Holding Version
1
+ # oficio-pro
2
2
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
3
+ Instalador do **Ofício Pro** (assinatura da Codetrade) para o Claude Code.
4
+
5
+ ```bash
6
+ npx oficio-pro
7
+ ```
8
+
9
+ Ele confere a sua chave no servidor do Ofício Pro, instala o plugin pelo marketplace
10
+ [`codetradeai/oficio-pro`](https://github.com/codetradeai/oficio-pro), salva a chave **só no seu computador**
11
+ (`~/.claude/settings.json`, permissão 600, com backup do arquivo anterior) e liga a atualização automática.
12
+
13
+ | Comando | O que faz |
14
+ |---|---|
15
+ | `npx oficio-pro` | instala ou reinstala |
16
+ | `npx oficio-pro status` | mostra plugin, atualização automática e assinatura |
17
+ | `npx oficio-pro atualizar` | baixa a versão mais nova do plugin |
18
+ | `npx oficio-pro trocar-chave` | troca a chave salva |
19
+ | `npx oficio-pro desinstalar` | remove o plugin e apaga a chave |
20
+
21
+ Opções: `--chave-stdin` (lê a chave da entrada), `--marketplace <dono/repo ou pasta>`, `--sim`, `--ajuda`.
22
+
23
+ **Segurança:** sem dependências; a chave só vai para `https://pro.codetrade.me` (nunca segue redirecionamento),
24
+ nunca aparece na tela, em logs ou nos argumentos do `claude`.
25
+
26
+ Precisa de Node.js 18+ e do [Claude Code](https://code.claude.com/docs/en/setup). Licença: ver `LICENSE`.
27
+ Dúvidas: contato@codetrade.me
@@ -0,0 +1,9 @@
1
+ #!/usr/bin/env node
2
+ // Ofício Pro · instalador (npx oficio-pro). Sem dependências.
3
+ const [maior] = process.versions.node.split(".").map(Number);
4
+ if (maior < 18) {
5
+ console.error(`O instalador do Ofício Pro precisa do Node.js 18 ou mais novo (você tem ${process.versions.node}). Baixe em https://nodejs.org`);
6
+ process.exit(1);
7
+ }
8
+ const { principal } = await import("../lib/cli.js");
9
+ process.exitCode = await principal(process.argv.slice(2));
package/lib/chave.js ADDED
@@ -0,0 +1,17 @@
1
+ // Formato da chave: opro_ + 32 caracteres do alfabeto sem 0/o/1/l/i (igual ao servidor).
2
+ const FORMATO = /^opro_[a-hj-km-np-z2-9]{32}$/;
3
+
4
+ /** Limpa o que a pessoa colou: espaços, aspas e quebras de linha nas pontas. */
5
+ export function limparChave(bruta) {
6
+ return String(bruta ?? "").trim().replace(/^["'`]+|["'`]+$/g, "").trim();
7
+ }
8
+
9
+ export function formatoValido(chave) {
10
+ return FORMATO.test(chave);
11
+ }
12
+
13
+ /** Para mostrar na tela sem revelar a chave: opro_ab•••• */
14
+ export function mascarar(chave) {
15
+ if (!chave) return "(nenhuma)";
16
+ return `${String(chave).slice(0, 7)}••••`;
17
+ }
package/lib/claude.js ADDED
@@ -0,0 +1,46 @@
1
+ // Acha e roda o `claude` (Claude Code CLI). A chave NUNCA vai nos argumentos (apareceria na lista de processos).
2
+ import { spawnSync } from "node:child_process";
3
+ import { existsSync, statSync } from "node:fs";
4
+ import { homedir } from "node:os";
5
+ import { delimiter, join } from "node:path";
6
+
7
+ function executavel(p) {
8
+ try { return existsSync(p) && statSync(p).isFile(); } catch { return false; }
9
+ }
10
+
11
+ /** Caminho do `claude`, ou null. OFICIO_PRO_CLAUDE aponta para outro binário (testes). */
12
+ export function acharClaude(env = process.env, home = homedir(), plataforma = process.platform) {
13
+ if (env.OFICIO_PRO_CLAUDE) return executavel(env.OFICIO_PRO_CLAUDE) ? env.OFICIO_PRO_CLAUDE : null;
14
+ const exts = plataforma === "win32" ? (env.PATHEXT || ".EXE;.CMD;.BAT").split(";").filter(Boolean).map((e) => e.toLowerCase()) : [""];
15
+ const pastas = (env.PATH || env.Path || "").split(plataforma === "win32" ? ";" : delimiter).filter(Boolean);
16
+ // Lugares comuns do instalador oficial, caso o PATH do terminal ainda não tenha sido recarregado.
17
+ pastas.push(join(home, ".local", "bin"), join(home, ".claude", "local"));
18
+ for (const d of pastas) for (const e of exts) {
19
+ const p = join(d, `claude${e}`);
20
+ if (executavel(p)) return p;
21
+ }
22
+ return null;
23
+ }
24
+
25
+ const aspas = (s) => `"${String(s).replace(/"/g, '\\"')}"`;
26
+
27
+ /** Roda o claude e devolve { codigo, saida, erro }. */
28
+ export function criarExecutor(caminho, { env = process.env, plataforma = process.platform } = {}) {
29
+ const precisaShell = plataforma === "win32" && /\.(cmd|bat)$/i.test(caminho);
30
+ return function rodar(args, { mostrar = false } = {}) {
31
+ const r = precisaShell
32
+ ? spawnSync([aspas(caminho), ...args.map(aspas)].join(" "), { shell: true, encoding: "utf8", env, stdio: mostrar ? ["inherit", "inherit", "inherit"] : "pipe", timeout: 180000 })
33
+ : spawnSync(caminho, args, { encoding: "utf8", env, stdio: mostrar ? ["inherit", "inherit", "inherit"] : "pipe", timeout: 180000 });
34
+ return { codigo: r.status ?? 1, saida: r.stdout ?? "", erro: (r.stderr ?? "") + (r.error ? String(r.error.message) : "") };
35
+ };
36
+ }
37
+
38
+ /** Lê JSON da saída do claude (`--json`), tolerando linhas extras antes. */
39
+ export function lerJsonSaida(texto) {
40
+ const t = String(texto || "").trim();
41
+ if (!t) return null;
42
+ try { return JSON.parse(t); } catch { /* segue */ }
43
+ const i = Math.min(...["[", "{"].map((c) => t.indexOf(c)).filter((x) => x >= 0));
44
+ if (Number.isFinite(i)) { try { return JSON.parse(t.slice(i)); } catch { /* segue */ } }
45
+ return null;
46
+ }
package/lib/cli.js ADDED
@@ -0,0 +1,80 @@
1
+ import { VERSAO } from "./constantes.js";
2
+ import { atualizar, desinstalar, ErroFluxo, instalar, status, trocarChave } from "./fluxos.js";
3
+ import { ErroSettings } from "./settings.js";
4
+ import { criarIO, negrito, vermelho } from "./terminal.js";
5
+
6
+ const COMANDOS = {
7
+ instalar, install: instalar,
8
+ atualizar, update: atualizar,
9
+ "trocar-chave": trocarChave,
10
+ desinstalar, uninstall: desinstalar,
11
+ status,
12
+ };
13
+
14
+ export const AJUDA = `
15
+ ${negrito("Ofício Pro · instalador")} ${VERSAO}
16
+
17
+ Uso:
18
+ npx oficio-pro instala (ou reinstala) o plugin e salva a sua chave
19
+ npx oficio-pro status mostra o que está instalado e se a chave vale
20
+ npx oficio-pro atualizar baixa a versão mais nova do plugin
21
+ npx oficio-pro trocar-chave troca a chave salva por uma nova
22
+ npx oficio-pro desinstalar remove o plugin e apaga a chave deste computador
23
+
24
+ Opções:
25
+ --chave-stdin lê a chave da entrada. Ex.: macOS: pbpaste | npx oficio-pro --chave-stdin
26
+ Linux: xclip -o | npx oficio-pro --chave-stdin · Windows (PowerShell): Get-Clipboard | npx oficio-pro --chave-stdin
27
+ --chave <chave> passa a chave direto (fica no histórico do terminal: evite)
28
+ --marketplace <x> origem do marketplace: dono/repo do GitHub ou pasta local (testes)
29
+ --sim, -y responde "sim" às confirmações
30
+ --ajuda, -h esta ajuda
31
+ --versao, -v versão do instalador
32
+
33
+ A chave fica só no seu computador (~/.claude/settings.json) e só é enviada para https://pro.codetrade.me.
34
+ Dúvidas: contato@codetrade.me
35
+ `;
36
+
37
+ export function lerArgs(argv) {
38
+ const o = { comando: null, chave: null, chaveStdin: false, marketplace: null, sim: false, ajuda: false, versao: false };
39
+ for (let i = 0; i < argv.length; i++) {
40
+ const a = argv[i];
41
+ const [nome, valorIgual] = a.startsWith("--") && a.includes("=") ? [a.slice(0, a.indexOf("=")), a.slice(a.indexOf("=") + 1)] : [a, undefined];
42
+ const valor = () => {
43
+ if (valorIgual !== undefined) return valorIgual;
44
+ const v = argv[++i];
45
+ if (v === undefined) throw new ErroFluxo(`Falta o valor de ${nome}.`);
46
+ return v;
47
+ };
48
+ if (nome === "--chave") o.chave = valor();
49
+ else if (nome === "--chave-stdin") o.chaveStdin = true;
50
+ else if (nome === "--marketplace") o.marketplace = valor();
51
+ else if (nome === "--sim" || nome === "-y" || nome === "--yes") o.sim = true;
52
+ else if (nome === "--ajuda" || nome === "-h" || nome === "--help" || nome === "ajuda" || nome === "help") o.ajuda = true;
53
+ else if (nome === "--versao" || nome === "-v" || nome === "--version") o.versao = true;
54
+ else if (!nome.startsWith("-") && !o.comando) o.comando = nome;
55
+ else throw new ErroFluxo(`Opção desconhecida: ${nome}. Veja: npx oficio-pro --ajuda`);
56
+ }
57
+ return o;
58
+ }
59
+
60
+ export async function principal(argv, deps = {}) {
61
+ const io = deps.io ?? criarIO();
62
+ let o;
63
+ try { o = lerArgs(argv); } catch (e) { io.escrever(vermelho(`✘ ${e.message}`)); return 1; }
64
+ if (o.versao) { io.escrever(VERSAO); return 0; }
65
+ if (o.ajuda) { io.escrever(AJUDA); return 0; }
66
+ const fn = COMANDOS[o.comando ?? "instalar"];
67
+ if (!fn) { io.escrever(vermelho(`✘ Comando desconhecido: ${o.comando}`)); io.escrever(AJUDA); return 1; }
68
+ try {
69
+ return await fn({ ...deps, io, opcoes: o });
70
+ } catch (e) {
71
+ if (e instanceof ErroFluxo || e instanceof ErroSettings) {
72
+ io.escrever(vermelho(`✘ ${e.message}`));
73
+ return e.codigo ?? 1;
74
+ }
75
+ // Erro inesperado: mostra só a mensagem (nunca variáveis, nunca a chave).
76
+ io.escrever(vermelho(`✘ Erro inesperado: ${e?.message ?? e}`));
77
+ io.escrever("Se continuar, escreva para contato@codetrade.me com esta mensagem (sem a sua chave).");
78
+ return 1;
79
+ }
80
+ }
@@ -0,0 +1,9 @@
1
+ // Valores fixos do instalador do Ofício Pro.
2
+ export const VERSAO = "2.1.0";
3
+ export const SERVIDOR_PADRAO = "https://pro.codetrade.me";
4
+ export const MARKETPLACE_PADRAO = "codetradeai/oficio-pro"; // repositório público no GitHub
5
+ export const NOME_MARKETPLACE = "oficio-pro";
6
+ export const NOME_PLUGIN = "oficio-pro";
7
+ export const PLUGIN_ID = `${NOME_PLUGIN}@${NOME_MARKETPLACE}`;
8
+ export const VAR_CHAVE = "OFICIO_PRO_CHAVE";
9
+ export const URL_REENVIO = `${SERVIDOR_PADRAO}/reenviar-chave`;
package/lib/fluxos.js ADDED
@@ -0,0 +1,323 @@
1
+ // Os comandos do instalador: instalar, atualizar, trocar-chave, desinstalar, status.
2
+ // Tudo recebe as dependências por parâmetro (terminal, fetch, claude, HOME) para poder ser testado.
3
+ import { existsSync } from "node:fs";
4
+ import { homedir } from "node:os";
5
+ import { isAbsolute, resolve } from "node:path";
6
+ import { formatoValido, limparChave, mascarar } from "./chave.js";
7
+ import { acharClaude, criarExecutor, lerJsonSaida } from "./claude.js";
8
+ import { MARKETPLACE_PADRAO, NOME_MARKETPLACE, PLUGIN_ID, URL_REENVIO, VAR_CHAVE, VERSAO } from "./constantes.js";
9
+ import { statusAssinatura, urlServidor, validarChave } from "./servidor.js";
10
+ import {
11
+ apagarBackup, autoUpdateLigado, caminhoSettings, chaveSalva, comAutoUpdate, comChave, ErroSettings,
12
+ lerSettings, permissaoAberta, salvarSettings, semChave,
13
+ } from "./settings.js";
14
+ import { amarelo, cinza, negrito, verde, vermelho } from "./terminal.js";
15
+
16
+ export class ErroFluxo extends Error {
17
+ constructor(msg, codigo = 1) { super(msg); this.codigo = codigo; }
18
+ }
19
+
20
+ /** De onde vem o marketplace: GitHub (padrão), URL git, ou pasta local (testes). */
21
+ export function resolverOrigem(valor, { cwd = process.cwd(), home = homedir() } = {}) {
22
+ const v = String(valor || MARKETPLACE_PADRAO).trim();
23
+ const expandido = v.startsWith("~") ? home + v.slice(1) : v;
24
+ const pareceCaminho = /^(\.{1,2}[\\/]|[\\/]|~|[a-zA-Z]:[\\/])/.test(v) || v === "." || v === "..";
25
+ if (pareceCaminho || (isAbsolute(expandido) && existsSync(expandido))) {
26
+ const caminho = resolve(cwd, expandido);
27
+ if (!existsSync(caminho)) throw new ErroFluxo(`A pasta do marketplace não existe: ${caminho}`);
28
+ return { tipo: "local", arg: caminho, rotulo: caminho, settings: { source: "directory", path: caminho } };
29
+ }
30
+ if (/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(v)) return { tipo: "github", arg: v, rotulo: `github.com/${v}`, settings: { source: "github", repo: v } };
31
+ if (/^(https:\/\/|git@|ssh:\/\/)/.test(v)) return { tipo: "git", arg: v, rotulo: v, settings: { source: "git", url: v } };
32
+ throw new ErroFluxo(`Origem do marketplace não reconhecida: ${v}`);
33
+ }
34
+
35
+ function mesmaOrigem(entrada, origem) {
36
+ if (!entrada) return false;
37
+ if (origem.tipo === "local") return entrada.path === origem.arg || entrada.installLocation === origem.arg;
38
+ if (origem.tipo === "github") return (entrada.repo || "").toLowerCase() === origem.arg.toLowerCase();
39
+ return entrada.url === origem.arg;
40
+ }
41
+
42
+ function contexto(d) {
43
+ const env = d.env ?? process.env;
44
+ const home = d.home ?? homedir();
45
+ const io = d.io;
46
+ const arquivo = caminhoSettings(env, home);
47
+ const caminhoClaude = d.caminhoClaude !== undefined ? d.caminhoClaude : acharClaude(env, home);
48
+ const claude = d.rodarClaude ?? (caminhoClaude ? criarExecutor(caminhoClaude, { env }) : null);
49
+ const fetchOpc = { fetch: d.fetch ?? globalThis.fetch, env };
50
+ return { ...d, env, home, io, arquivo, caminhoClaude, claude, fetchOpc, opcoes: d.opcoes ?? {} };
51
+ }
52
+
53
+ function cabecalho(io, titulo) {
54
+ io.escrever("");
55
+ io.escrever(negrito(` ✦ Ofício Pro · ${titulo}`));
56
+ io.escrever(cinza(` instalador ${VERSAO} · Codetrade`));
57
+ io.escrever("");
58
+ }
59
+
60
+ function explicarClaude(io) {
61
+ io.escrever(vermelho("✘ Não encontrei o Claude Code (comando `claude`) neste computador."));
62
+ io.escrever("");
63
+ io.escrever(" Instale primeiro e depois rode este instalador de novo:");
64
+ io.escrever(` • macOS ou Linux: ${negrito("curl -fsSL https://claude.ai/install.sh | bash")}`);
65
+ io.escrever(` • Windows (PowerShell): ${negrito("irm https://claude.ai/install.ps1 | iex")}`);
66
+ io.escrever(` • ou com Homebrew (macOS): ${negrito("brew install --cask claude-code")}`);
67
+ io.escrever(cinza(" Guia oficial: https://code.claude.com/docs/en/setup"));
68
+ io.escrever(cinza(" Depois de instalar, feche e abra o Terminal e confira com: claude --version"));
69
+ }
70
+
71
+ function exigirClaude(c) {
72
+ if (!c.claude) { explicarClaude(c.io); throw new ErroFluxo("Claude Code não encontrado.", 1); }
73
+ const v = c.claude(["--version"]);
74
+ if (v.codigo !== 0) { explicarClaude(c.io); throw new ErroFluxo("O comando `claude` não respondeu.", 1); }
75
+ c.io.escrever(verde(`✔ Claude Code encontrado`) + cinza(` (${v.saida.trim().split("\n")[0] || "versão desconhecida"})`));
76
+ }
77
+
78
+ /** Pede a chave: --chave, --chave-stdin, chave já salva (com confirmação) ou digitada (mascarada). */
79
+ async function obterChave(c, { podeReusar }) {
80
+ const { io, opcoes } = c;
81
+ if (opcoes.chave) {
82
+ io.escrever(amarelo("⚠ Você passou a chave em --chave: ela pode ficar no histórico do terminal. Da próxima vez, rode sem --chave e cole quando eu pedir."));
83
+ return limparChave(opcoes.chave);
84
+ }
85
+ if (opcoes.chaveStdin) return limparChave(await io.lerTudo());
86
+ if (podeReusar) {
87
+ const atual = chaveSalva(lerSettings(c.arquivo));
88
+ if (atual && (opcoes.sim || !io.interativo || await io.confirmar(`Já existe uma chave salva (${mascarar(atual)}). Usar a mesma?`))) return atual;
89
+ }
90
+ if (!io.interativo) throw new ErroFluxo("Sem terminal para digitar a chave. Use --chave-stdin (ex.: pbpaste | npx oficio-pro --chave-stdin no macOS, Get-Clipboard | npx oficio-pro --chave-stdin no Windows).", 1);
91
+ io.escrever("Cole a sua chave do Ofício Pro (chega por e-mail e começa com opro_).");
92
+ io.escrever(cinza("Ela não aparece na tela enquanto você cola. Depois, aperte Enter."));
93
+ return limparChave(await io.lerOculto("Chave: "));
94
+ }
95
+
96
+ /** Pede e confere a chave no servidor. Até 3 tentativas no modo interativo. */
97
+ async function chaveConferida(c, { podeReusar }) {
98
+ const { io } = c;
99
+ const servidor = urlServidor(c.env); // falha cedo se OFICIO_PRO_SERVIDOR for inseguro
100
+ if (servidor !== "https://pro.codetrade.me") io.escrever(amarelo(`⚠ Modo teste: servidor ${servidor}`));
101
+ for (let tentativa = 1; tentativa <= 3; tentativa++) {
102
+ const chave = await obterChave(c, { podeReusar: podeReusar && tentativa === 1 });
103
+ const repetir = io.interativo && !c.opcoes.chave && !c.opcoes.chaveStdin && tentativa < 3;
104
+ if (!formatoValido(chave)) {
105
+ io.escrever(vermelho("✘ Isso não parece uma chave do Ofício Pro (opro_ + 32 letras e números)."));
106
+ if (repetir) continue;
107
+ throw new ErroFluxo("Chave em formato inválido.", 2);
108
+ }
109
+ io.escrever(cinza("… conferindo a chave no servidor do Ofício Pro"));
110
+ const r = await validarChave(chave, c.fetchOpc);
111
+ if (r.estado === "valida") { io.escrever(verde(`✔ Chave válida (${mascarar(chave)})`)); return chave; }
112
+ if (r.estado === "invalida") {
113
+ io.escrever(vermelho(`✘ ${r.mensagem}`));
114
+ io.escrever(cinza(` Perdeu a chave? Peça outra em ${URL_REENVIO}`));
115
+ if (repetir) continue;
116
+ throw new ErroFluxo("Chave recusada pelo servidor.", 2);
117
+ }
118
+ if (r.estado === "inativa") { io.escrever(vermelho(`✘ ${r.mensagem}`)); throw new ErroFluxo("Assinatura sem acesso.", 2); }
119
+ if (r.estado === "limite") { io.escrever(vermelho(`✘ ${r.mensagem}`)); throw new ErroFluxo("Muitas tentativas.", 2); }
120
+ io.escrever(vermelho(`✘ ${r.mensagem}`));
121
+ if (r.estado === "rede" && io.interativo && !c.opcoes.sim && await io.confirmar("Salvar a chave mesmo sem conferir agora?", false)) return chave;
122
+ throw new ErroFluxo("Não deu para conferir a chave.", 1);
123
+ }
124
+ throw new ErroFluxo("Chave não aceita depois de 3 tentativas.", 2);
125
+ }
126
+
127
+ function listarMarketplaces(c) {
128
+ const r = c.claude(["plugin", "marketplace", "list", "--json"]);
129
+ const j = r.codigo === 0 ? lerJsonSaida(r.saida) : null;
130
+ return Array.isArray(j) ? j : null;
131
+ }
132
+
133
+ function listarPlugins(c) {
134
+ const r = c.claude(["plugin", "list", "--json"]);
135
+ const j = r.codigo === 0 ? lerJsonSaida(r.saida) : null;
136
+ return Array.isArray(j) ? j : null;
137
+ }
138
+
139
+ function passo(c, rotulo, args) {
140
+ c.io.escrever(cinza(`… ${rotulo}`) + cinza(` (claude ${args.join(" ")})`));
141
+ const r = c.claude(args);
142
+ if (r.codigo !== 0) {
143
+ const detalhe = (r.erro || r.saida).trim().split("\n").slice(-3).join(" ").slice(0, 400);
144
+ c.io.escrever(vermelho(`✘ Falhou: ${rotulo}`) + (detalhe ? cinza(` · ${detalhe}`) : ""));
145
+ return false;
146
+ }
147
+ return true;
148
+ }
149
+
150
+ /** Marketplace + plugin pelo CLI. Devolve true se deu tudo certo. */
151
+ async function instalarPlugin(c, origem) {
152
+ const { io } = c;
153
+ const mkts = listarMarketplaces(c);
154
+ const atual = mkts?.find((m) => m.name === NOME_MARKETPLACE);
155
+ if (atual && !mesmaOrigem(atual, origem)) {
156
+ io.escrever(amarelo(`⚠ Já existe um marketplace "${NOME_MARKETPLACE}" vindo de outro lugar (${atual.path || atual.repo || atual.url || atual.source}).`));
157
+ io.escrever(" Vou trocar pela origem oficial. O plugin é reinstalado em seguida; a sua chave não muda.");
158
+ if (!c.opcoes.sim && io.interativo && !(await io.confirmar("Pode trocar?"))) return false;
159
+ if (!passo(c, "removendo o marketplace antigo", ["plugin", "marketplace", "remove", NOME_MARKETPLACE])) return false;
160
+ }
161
+ if (atual && mesmaOrigem(atual, origem)) {
162
+ if (!passo(c, "atualizando o marketplace", ["plugin", "marketplace", "update", NOME_MARKETPLACE])) return false;
163
+ } else if (!passo(c, `adicionando o marketplace (${origem.rotulo})`, ["plugin", "marketplace", "add", origem.arg])) {
164
+ return false;
165
+ }
166
+ io.escrever(verde("✔ Marketplace pronto"));
167
+
168
+ const instalado = listarPlugins(c)?.some((p) => p.id === PLUGIN_ID);
169
+ const ok = instalado
170
+ ? passo(c, "atualizando o plugin", ["plugin", "update", PLUGIN_ID])
171
+ : passo(c, "instalando o plugin", ["plugin", "install", PLUGIN_ID, "--scope", "user"]);
172
+ if (ok) io.escrever(verde(`✔ Plugin ${PLUGIN_ID} ${instalado ? "atualizado" : "instalado"}`));
173
+ return ok;
174
+ }
175
+
176
+ function instrucoesManuais(io, origem) {
177
+ io.escrever("");
178
+ io.escrever(amarelo("Não consegui instalar o plugin sozinho. Faça à mão (leva 1 minuto):"));
179
+ io.escrever(` 1. Abra o Terminal e digite ${negrito("claude")}`);
180
+ io.escrever(` 2. Dentro do Claude Code, cole: ${negrito(`/plugin marketplace add ${origem.arg}`)}`);
181
+ io.escrever(` 3. Depois: ${negrito(`/plugin install ${PLUGIN_ID}`)}`);
182
+ io.escrever(` 4. Em /plugin → Marketplaces → ${NOME_MARKETPLACE}, escolha "Enable auto-update".`);
183
+ io.escrever(cinza(" A chave já ficou salva (se apareceu ✔ acima); não precisa colar de novo."));
184
+ }
185
+
186
+ function salvarComChave(c, chave, origem) {
187
+ let s = comChave(lerSettings(c.arquivo), chave);
188
+ if (origem !== undefined) s = comAutoUpdate(s, origem?.settings ?? null);
189
+ const backup = salvarSettings(c.arquivo, s);
190
+ c.io.escrever(verde(`✔ Chave salva só neste computador`) + cinza(` (${c.arquivo}, em "env" → ${VAR_CHAVE})`));
191
+ if (backup) c.io.escrever(cinza(` Cópia do arquivo anterior: ${backup}`));
192
+ if (origem !== undefined) c.io.escrever(autoUpdateLigado(s) ? verde("✔ Atualização automática do plugin ligada") : amarelo("⚠ Não deu para ligar a atualização automática (ligue em /plugin → Marketplaces)."));
193
+ }
194
+
195
+ function finalizar(io) {
196
+ io.escrever("");
197
+ io.escrever(negrito("Pronto! Agora:"));
198
+ io.escrever(` 1. Feche e abra o Claude Code (o que estiver aberto não vê a chave nova).`);
199
+ io.escrever(` 2. Digite ${negrito("/mcp")}: o ${negrito("oficio-pro")} deve aparecer conectado.`);
200
+ io.escrever(` 3. Teste: ${negrito("/oficio-pro:decidir aceito o emprego novo ou fico?")}`);
201
+ io.escrever(cinza(" Ver depois: npx oficio-pro status · Trocar a chave: npx oficio-pro trocar-chave"));
202
+ io.escrever("");
203
+ }
204
+
205
+ export async function instalar(d) {
206
+ const c = contexto(d);
207
+ cabecalho(c.io, "instalação");
208
+ c.io.escrever("Olá! Vou deixar o Ofício Pro pronto no seu Claude Code em 3 passos: conferir a chave, instalar o plugin e salvar a chave.");
209
+ c.io.escrever("");
210
+ const origem = resolverOrigem(c.opcoes.marketplace || c.env.OFICIO_PRO_MARKETPLACE, { home: c.home });
211
+ if (origem.tipo !== "github" || origem.arg !== MARKETPLACE_PADRAO) c.io.escrever(amarelo(`⚠ Marketplace de teste: ${origem.rotulo}`));
212
+ exigirClaude(c);
213
+ lerSettings(c.arquivo); // se o settings.json estiver quebrado, para aqui, antes de qualquer coisa
214
+ const chave = await chaveConferida(c, { podeReusar: true });
215
+ const ok = await instalarPlugin(c, origem);
216
+ salvarComChave(c, chave, origem);
217
+ if (!ok) { instrucoesManuais(c.io, origem); return 3; }
218
+ finalizar(c.io);
219
+ return 0;
220
+ }
221
+
222
+ export async function trocarChave(d) {
223
+ const c = contexto(d);
224
+ cabecalho(c.io, "trocar a chave");
225
+ lerSettings(c.arquivo);
226
+ const antiga = chaveSalva(lerSettings(c.arquivo));
227
+ if (antiga) c.io.escrever(cinza(`Chave atual: ${mascarar(antiga)}`));
228
+ const chave = await chaveConferida(c, { podeReusar: false });
229
+ salvarComChave(c, chave, undefined);
230
+ c.io.escrever("");
231
+ c.io.escrever(`Feche e abra o Claude Code para usar a chave nova. Confira com ${negrito("/mcp")}.`);
232
+ return 0;
233
+ }
234
+
235
+ export async function atualizar(d) {
236
+ const c = contexto(d);
237
+ cabecalho(c.io, "atualizar");
238
+ exigirClaude(c);
239
+ const ok1 = passo(c, "atualizando o marketplace", ["plugin", "marketplace", "update", NOME_MARKETPLACE]);
240
+ const ok2 = ok1 && passo(c, "atualizando o plugin", ["plugin", "update", PLUGIN_ID]);
241
+ const s = lerSettings(c.arquivo);
242
+ if (!autoUpdateLigado(s) && s?.extraKnownMarketplaces?.[NOME_MARKETPLACE]) {
243
+ salvarSettings(c.arquivo, comAutoUpdate(s, null));
244
+ c.io.escrever(verde("✔ Atualização automática ligada"));
245
+ }
246
+ if (!ok2) {
247
+ c.io.escrever(amarelo("Se o plugin não estiver instalado, rode: npx oficio-pro"));
248
+ return 1;
249
+ }
250
+ c.io.escrever(verde("✔ Tudo atualizado. Feche e abra o Claude Code para carregar a versão nova."));
251
+ return 0;
252
+ }
253
+
254
+ export async function desinstalar(d) {
255
+ const c = contexto(d);
256
+ cabecalho(c.io, "desinstalar");
257
+ lerSettings(c.arquivo);
258
+ if (!c.opcoes.sim) {
259
+ if (!c.io.interativo) throw new ErroFluxo("Para desinstalar sem terminal, use --sim.", 1);
260
+ if (!(await c.io.confirmar("Remover o plugin Ofício Pro e apagar a chave deste computador?", false))) { c.io.escrever("Nada foi mudado."); return 0; }
261
+ }
262
+ let ok = true;
263
+ if (c.claude) {
264
+ const instalado = listarPlugins(c)?.some((p) => p.id === PLUGIN_ID);
265
+ if (instalado !== false) ok = passo(c, "removendo o plugin", ["plugin", "uninstall", PLUGIN_ID]) && ok;
266
+ const mkt = listarMarketplaces(c)?.some((m) => m.name === NOME_MARKETPLACE);
267
+ if (mkt !== false) ok = passo(c, "removendo o marketplace", ["plugin", "marketplace", "remove", NOME_MARKETPLACE]) && ok;
268
+ } else {
269
+ c.io.escrever(amarelo("⚠ Claude Code não encontrado: só vou apagar a chave."));
270
+ }
271
+ const s = semChave(lerSettings(c.arquivo));
272
+ if (s.extraKnownMarketplaces?.[NOME_MARKETPLACE]) {
273
+ delete s.extraKnownMarketplaces[NOME_MARKETPLACE];
274
+ if (!Object.keys(s.extraKnownMarketplaces).length) delete s.extraKnownMarketplaces;
275
+ }
276
+ if (s.enabledPlugins && PLUGIN_ID in s.enabledPlugins) {
277
+ delete s.enabledPlugins[PLUGIN_ID];
278
+ if (!Object.keys(s.enabledPlugins).length) delete s.enabledPlugins;
279
+ }
280
+ salvarSettings(c.arquivo, s);
281
+ apagarBackup(c.arquivo); // o backup ainda teria a chave
282
+ c.io.escrever(verde("✔ Chave apagada deste computador"));
283
+ c.io.escrever(ok ? verde("✔ Ofício Pro removido. Até breve!") : amarelo("⚠ Parte da remoção falhou; veja acima. A chave já foi apagada."));
284
+ c.io.escrever(cinza(" Isto não cancela a assinatura. Para cancelar: consumer.hotmart.com"));
285
+ return ok ? 0 : 1;
286
+ }
287
+
288
+ export async function status(d) {
289
+ const c = contexto(d);
290
+ cabecalho(c.io, "status");
291
+ const { io } = c;
292
+ let s = {};
293
+ try { s = lerSettings(c.arquivo); } catch (e) { io.escrever(vermelho(`✘ ${e.message}`)); }
294
+ if (c.claude) {
295
+ const v = c.claude(["--version"]);
296
+ io.escrever(`${verde("✔")} Claude Code: ${v.saida.trim().split("\n")[0] || "?"}`);
297
+ const p = listarPlugins(c)?.find((x) => x.id === PLUGIN_ID);
298
+ io.escrever(p ? `${verde("✔")} Plugin: ${PLUGIN_ID} ${p.version ?? ""}${p.enabled === false ? amarelo(" (desligado)") : ""}` : `${vermelho("✘")} Plugin: não instalado (rode npx oficio-pro)`);
299
+ const m = listarMarketplaces(c)?.find((x) => x.name === NOME_MARKETPLACE);
300
+ io.escrever(m ? `${verde("✔")} Marketplace: ${m.repo || m.path || m.url || m.source}` : `${vermelho("✘")} Marketplace: não adicionado`);
301
+ } else {
302
+ io.escrever(`${vermelho("✘")} Claude Code: não encontrado`);
303
+ }
304
+ io.escrever(autoUpdateLigado(s) ? `${verde("✔")} Atualização automática: ligada` : `${amarelo("•")} Atualização automática: desligada`);
305
+ const chave = chaveSalva(s);
306
+ if (!chave) {
307
+ io.escrever(`${vermelho("✘")} Chave: não salva em ${c.arquivo}`);
308
+ return 1;
309
+ }
310
+ io.escrever(`${verde("✔")} Chave: ${mascarar(chave)} (em ${c.arquivo})`);
311
+ if (permissaoAberta(c.arquivo)) io.escrever(amarelo(`⚠ Outras contas deste computador podem ler o arquivo. Rode: chmod 600 "${c.arquivo}"`));
312
+ const r = await validarChave(chave, c.fetchOpc);
313
+ if (r.estado === "valida") {
314
+ const t = await statusAssinatura(chave, c.fetchOpc);
315
+ io.escrever(`${verde("✔")} Servidor: chave aceita`);
316
+ if (t) for (const l of t.split("\n").filter((x) => !/^Chave:/.test(x))) io.escrever(` ${l}`);
317
+ return 0;
318
+ }
319
+ io.escrever(`${vermelho("✘")} Servidor: ${r.mensagem}`);
320
+ return 2;
321
+ }
322
+
323
+ export { ErroSettings };
@@ -0,0 +1,81 @@
1
+ // Conversa com o servidor do Ofício Pro. A chave só vai para https://pro.codetrade.me
2
+ // (ou para localhost, em testes com OFICIO_PRO_SERVIDOR). Nunca segue redirecionamento.
3
+ import { SERVIDOR_PADRAO, VERSAO } from "./constantes.js";
4
+
5
+ /** Endereço do servidor. Só aceita o oficial (HTTPS) ou localhost (testes). */
6
+ export function urlServidor(env = process.env) {
7
+ const bruto = (env.OFICIO_PRO_SERVIDOR || "").trim().replace(/\/+$/, "");
8
+ if (!bruto) return SERVIDOR_PADRAO;
9
+ let u;
10
+ try { u = new URL(bruto); } catch { throw new Error("OFICIO_PRO_SERVIDOR não é um endereço válido."); }
11
+ const local = ["localhost", "127.0.0.1", "[::1]"].includes(u.hostname);
12
+ if (u.origin === SERVIDOR_PADRAO || (local && (u.protocol === "http:" || u.protocol === "https:"))) return u.origin;
13
+ throw new Error("Por segurança, a chave só é enviada para https://pro.codetrade.me (ou localhost, em testes).");
14
+ }
15
+
16
+ const INIT = {
17
+ jsonrpc: "2.0", id: 1, method: "initialize",
18
+ params: { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "oficio-pro-instalador", version: VERSAO } },
19
+ };
20
+
21
+ async function postarMcp(chave, corpo, { fetch = globalThis.fetch, env = process.env, timeoutMs = 15000 } = {}) {
22
+ const url = `${urlServidor(env)}/mcp`;
23
+ const ctrl = new AbortController();
24
+ const t = setTimeout(() => ctrl.abort(), timeoutMs);
25
+ try {
26
+ return await fetch(url, {
27
+ method: "POST",
28
+ redirect: "error", // a chave nunca segue para outro endereço
29
+ signal: ctrl.signal,
30
+ headers: {
31
+ authorization: `Bearer ${chave}`,
32
+ "content-type": "application/json",
33
+ accept: "application/json, text/event-stream",
34
+ "user-agent": `oficio-pro-instalador/${VERSAO}`,
35
+ },
36
+ body: JSON.stringify(corpo),
37
+ });
38
+ } finally {
39
+ clearTimeout(t);
40
+ }
41
+ }
42
+
43
+ async function lerMensagem(r) {
44
+ try { const j = await r.json(); return j?.error?.message || ""; } catch { return ""; }
45
+ }
46
+
47
+ /**
48
+ * Confere a chave no servidor (um "initialize" do MCP, leve e sem efeito).
49
+ * estado: valida | invalida (401) | inativa (403: cancelada, atrasada...) | limite (429) | rede | erro
50
+ * Nunca devolve nem registra a chave.
51
+ */
52
+ export async function validarChave(chave, opcoes = {}) {
53
+ let r;
54
+ try {
55
+ r = await postarMcp(chave, INIT, opcoes);
56
+ } catch (e) {
57
+ if (e && /OFICIO_PRO_SERVIDOR|segurança/.test(String(e.message))) return { estado: "erro", mensagem: e.message };
58
+ return { estado: "rede", mensagem: "Não consegui falar com o servidor do Ofício Pro. Confira a internet e tente de novo." };
59
+ }
60
+ if (r.status === 200) return { estado: "valida", status: 200 };
61
+ const msg = await lerMensagem(r);
62
+ if (r.status === 401) return { estado: "invalida", status: 401, mensagem: msg || "Chave não reconhecida." };
63
+ if (r.status === 403) return { estado: "inativa", status: 403, mensagem: msg || "Assinatura sem acesso no momento." };
64
+ if (r.status === 429) {
65
+ const s = Number(r.headers.get("retry-after")) || 0;
66
+ return { estado: "limite", status: 429, mensagem: msg || `Muitas tentativas. Tente de novo em ${Math.max(1, Math.ceil(s / 60))} min.` };
67
+ }
68
+ return { estado: "erro", status: r.status, mensagem: `O servidor respondeu ${r.status}. Tente de novo em alguns minutos.` };
69
+ }
70
+
71
+ /** Texto da ferramenta status_assinatura (status, plano, prefixo da chave). Null se não der. */
72
+ export async function statusAssinatura(chave, opcoes = {}) {
73
+ try {
74
+ const r = await postarMcp(chave, { jsonrpc: "2.0", id: 2, method: "tools/call", params: { name: "status_assinatura", arguments: {} } }, opcoes);
75
+ if (r.status !== 200) return null;
76
+ const j = await r.json();
77
+ return j?.result?.content?.[0]?.text ?? null;
78
+ } catch {
79
+ return null;
80
+ }
81
+ }
@@ -0,0 +1,101 @@
1
+ // Leitura e escrita segura do ~/.claude/settings.json (ou $CLAUDE_CONFIG_DIR/settings.json).
2
+ // Regras: nunca sobrescreve um arquivo que não é JSON válido; faz backup (600) antes de mudar;
3
+ // grava num arquivo temporário (600) e troca de uma vez (rename), para não deixar o arquivo pela metade.
4
+ import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
5
+ import { homedir } from "node:os";
6
+ import { dirname, join } from "node:path";
7
+ import { NOME_MARKETPLACE, VAR_CHAVE } from "./constantes.js";
8
+
9
+ export class ErroSettings extends Error {}
10
+
11
+ export function pastaClaude(env = process.env, home = homedir()) {
12
+ return env.CLAUDE_CONFIG_DIR && env.CLAUDE_CONFIG_DIR.trim() ? env.CLAUDE_CONFIG_DIR.trim() : join(home, ".claude");
13
+ }
14
+
15
+ export const caminhoSettings = (env, home) => join(pastaClaude(env, home), "settings.json");
16
+ export const caminhoBackup = (arquivo) => `${arquivo}.oficio-pro.bak`;
17
+
18
+ /** Lê o JSON. Arquivo ausente ou vazio = {}. JSON inválido = erro (não mexemos). */
19
+ export function lerSettings(arquivo) {
20
+ if (!existsSync(arquivo)) return {};
21
+ const texto = readFileSync(arquivo, "utf8").replace(/^\uFEFF/, "");
22
+ if (!texto.trim()) return {};
23
+ let obj;
24
+ try { obj = JSON.parse(texto); } catch {
25
+ throw new ErroSettings(`O arquivo ${arquivo} não é um JSON válido. Corrija (ou renomeie) e rode de novo: não vou mexer nele assim.`);
26
+ }
27
+ if (!obj || typeof obj !== "object" || Array.isArray(obj)) throw new ErroSettings(`O arquivo ${arquivo} não tem um objeto JSON.`);
28
+ return obj;
29
+ }
30
+
31
+ const ehObjeto = (v) => v && typeof v === "object" && !Array.isArray(v);
32
+
33
+ /** Coloca a chave em env.OFICIO_PRO_CHAVE sem tocar no resto. Não altera o objeto original. */
34
+ export function comChave(settings, chave) {
35
+ const s = structuredClone(settings);
36
+ if (s.env !== undefined && !ehObjeto(s.env)) throw new ErroSettings('O campo "env" do settings.json não é um objeto. Corrija à mão e rode de novo.');
37
+ s.env = { ...(s.env ?? {}), [VAR_CHAVE]: chave };
38
+ return s;
39
+ }
40
+
41
+ export function semChave(settings) {
42
+ const s = structuredClone(settings);
43
+ if (ehObjeto(s.env)) {
44
+ delete s.env[VAR_CHAVE];
45
+ if (!Object.keys(s.env).length) delete s.env;
46
+ }
47
+ return s;
48
+ }
49
+
50
+ export const chaveSalva = (settings) => (ehObjeto(settings.env) && typeof settings.env[VAR_CHAVE] === "string" ? settings.env[VAR_CHAVE] : "");
51
+
52
+ /**
53
+ * Liga o autoUpdate do marketplace (extraKnownMarketplaces.<nome>.autoUpdate = true).
54
+ * Se o Claude Code não criou a entrada, criamos com a mesma origem usada no `marketplace add`.
55
+ */
56
+ export function comAutoUpdate(settings, origem, nome = NOME_MARKETPLACE) {
57
+ const s = structuredClone(settings);
58
+ if (s.extraKnownMarketplaces !== undefined && !ehObjeto(s.extraKnownMarketplaces)) return s;
59
+ s.extraKnownMarketplaces = { ...(s.extraKnownMarketplaces ?? {}) };
60
+ const atual = ehObjeto(s.extraKnownMarketplaces[nome]) ? s.extraKnownMarketplaces[nome] : null;
61
+ if (atual) s.extraKnownMarketplaces[nome] = { ...atual, autoUpdate: true };
62
+ else if (origem) s.extraKnownMarketplaces[nome] = { source: origem, autoUpdate: true };
63
+ return s;
64
+ }
65
+
66
+ export const autoUpdateLigado = (settings, nome = NOME_MARKETPLACE) =>
67
+ settings?.extraKnownMarketplaces?.[nome]?.autoUpdate === true;
68
+
69
+ /** Grava com backup do arquivo anterior. Devolve o caminho do backup (ou null se não havia arquivo). */
70
+ export function salvarSettings(arquivo, obj) {
71
+ mkdirSync(dirname(arquivo), { recursive: true, mode: 0o700 });
72
+ let backup = null;
73
+ if (existsSync(arquivo)) {
74
+ backup = caminhoBackup(arquivo);
75
+ copyFileSync(arquivo, backup);
76
+ try { chmodSync(backup, 0o600); } catch { /* Windows */ }
77
+ }
78
+ const tmp = `${arquivo}.oficio-pro.tmp-${process.pid}`;
79
+ writeFileSync(tmp, `${JSON.stringify(obj, null, 2)}\n`, { mode: 0o600 });
80
+ try { chmodSync(tmp, 0o600); } catch { /* Windows */ }
81
+ try {
82
+ renameSync(tmp, arquivo);
83
+ } catch (e) {
84
+ rmSync(tmp, { force: true });
85
+ throw e;
86
+ }
87
+ // Confere: o que ficou no disco é JSON válido e igual ao que queríamos.
88
+ const relido = lerSettings(arquivo);
89
+ if (JSON.stringify(relido) !== JSON.stringify(obj)) throw new ErroSettings("A gravação do settings.json não conferiu. O backup está em " + backup);
90
+ return backup;
91
+ }
92
+
93
+ /** true se o arquivo pode ser lido por outros usuários (só faz sentido em macOS/Linux). */
94
+ export function permissaoAberta(arquivo) {
95
+ if (process.platform === "win32" || !existsSync(arquivo)) return false;
96
+ return (statSync(arquivo).mode & 0o077) !== 0;
97
+ }
98
+
99
+ export function apagarBackup(arquivo) {
100
+ rmSync(caminhoBackup(arquivo), { force: true });
101
+ }
@@ -0,0 +1,73 @@
1
+ // Entrada e saída no terminal: perguntas, chave mascarada e cores simples.
2
+ import { createInterface } from "node:readline";
3
+
4
+ const cor = (n) => (s) => (process.stdout.isTTY && !process.env.NO_COLOR ? `\x1b[${n}m${s}\x1b[0m` : String(s));
5
+ export const negrito = cor(1);
6
+ export const verde = cor(32);
7
+ export const amarelo = cor(33);
8
+ export const vermelho = cor(31);
9
+ export const cinza = cor(90);
10
+
11
+ export function criarIO({ entrada = process.stdin, saida = process.stdout } = {}) {
12
+ const escrever = (s = "") => saida.write(`${s}\n`);
13
+
14
+ function lerLinha(pergunta) {
15
+ return new Promise((res) => {
16
+ const rl = createInterface({ input: entrada, output: saida, terminal: false });
17
+ saida.write(pergunta);
18
+ let feito = false;
19
+ rl.once("line", (l) => { feito = true; rl.close(); res(l); });
20
+ rl.once("close", () => { if (!feito) res(""); });
21
+ });
22
+ }
23
+
24
+ /** Lê a chave sem mostrar o que foi digitado (mostra • por caractere). */
25
+ function lerOculto(pergunta) {
26
+ if (!entrada.isTTY || typeof entrada.setRawMode !== "function") return lerLinha(pergunta);
27
+ return new Promise((res) => {
28
+ saida.write(pergunta);
29
+ let valor = "";
30
+ const bruto = entrada.isRaw;
31
+ entrada.setRawMode(true);
32
+ entrada.resume();
33
+ entrada.setEncoding("utf8");
34
+ const fim = (cancelado) => {
35
+ entrada.removeListener("data", aoDigitar);
36
+ entrada.setRawMode(bruto);
37
+ entrada.pause();
38
+ saida.write("\n");
39
+ if (cancelado) { escrever("Cancelado."); process.exit(130); }
40
+ res(valor);
41
+ };
42
+ function aoDigitar(pedaco) {
43
+ // Tira sequências de escape (setas, colar entre colchetes etc.).
44
+ const limpo = String(pedaco).replace(/\x1b\[[0-9;]*[~A-Za-z]/g, "").replace(/\x1b./g, "");
45
+ for (const ch of limpo) {
46
+ if (ch === "\r" || ch === "\n") return fim(false);
47
+ if (ch === "\u0003" || ch === "\u0004") return fim(true);
48
+ if (ch === "\u007f" || ch === "\b") {
49
+ if (valor) { valor = valor.slice(0, -1); saida.write("\b \b"); }
50
+ continue;
51
+ }
52
+ if (ch >= " ") { valor += ch; saida.write("•"); }
53
+ }
54
+ }
55
+ entrada.on("data", aoDigitar);
56
+ });
57
+ }
58
+
59
+ async function confirmar(pergunta, padrao = true) {
60
+ const r = (await lerLinha(`${pergunta} ${padrao ? "[S/n]" : "[s/N]"} `)).trim().toLowerCase();
61
+ if (!r) return padrao;
62
+ return ["s", "sim", "y", "yes"].includes(r);
63
+ }
64
+
65
+ async function lerTudo() {
66
+ let t = "";
67
+ entrada.setEncoding?.("utf8");
68
+ for await (const c of entrada) t += c;
69
+ return t;
70
+ }
71
+
72
+ return { escrever, lerLinha, lerOculto, confirmar, lerTudo, interativo: !!entrada.isTTY };
73
+ }
package/package.json CHANGED
@@ -1,6 +1,43 @@
1
1
  {
2
2
  "name": "oficio-pro",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
3
+ "version": "2.1.0",
4
+ "description": "Instalador do Ofício Pro (assinatura) da Codetrade para o Claude Code: confere a sua chave, instala o plugin e deixa tudo pronto.",
5
+ "type": "module",
6
+ "bin": {
7
+ "oficio-pro": "bin/oficio-pro.js"
8
+ },
9
+ "files": [
10
+ "bin/",
11
+ "lib/",
12
+ "README.md",
13
+ "LICENSE"
14
+ ],
15
+ "engines": {
16
+ "node": ">=18"
17
+ },
18
+ "scripts": {
19
+ "test": "node --test"
20
+ },
21
+ "keywords": [
22
+ "claude-code",
23
+ "plugin",
24
+ "oficio",
25
+ "pt-br",
26
+ "codetrade"
27
+ ],
28
+ "author": "Codetrade / C&T.AI <contato@codetrade.me> (https://codetrade.me)",
29
+ "homepage": "https://github.com/codetradeai/oficio-pro#readme",
30
+ "repository": {
31
+ "type": "git",
32
+ "url": "git+https://github.com/codetradeai/oficio-pro.git",
33
+ "directory": "installer"
34
+ },
35
+ "bugs": {
36
+ "email": "contato@codetrade.me"
37
+ },
38
+ "license": "SEE LICENSE IN LICENSE",
39
+ "publishConfig": {
40
+ "access": "public",
41
+ "provenance": false
42
+ }
43
+ }