brito-cli 0.11.0 → 0.13.0

package/README.md

@@ -278,6 +278,8 @@ With Claude as the main model (API or `claude` CLI), the `qwen` profile is the a
 
 `/orquestrar on` keeps Claude as the main model but hands the implementation to an endpoint profile (`qwen` by default). Claude writes the spec and the task list to `spec/<feature>/spec.md` and `spec/<feature>/tasks.md` (`spec_save` tool), waits for your approval, and only then sends one task at a time to the `implement` tool, checking off in `tasks.md` the ones that pass its review. It loses its file-editing tools (`write_file`/`edit_file`, or `Edit`/`Write`/`MultiEdit`/`NotebookEdit` in `claude` CLI mode): its only write is `spec_save`, which can only write those two files. It keeps reading, the graph and `bash` to check the work.
 
+**Desktop app.** The selector next to the model chooses who writes the code: **Claude**, or the **local Qwen3-4B** (`brito slm pull` first; no tokens, but a 4B model is weaker on multi-step tasks, so Claude still reviews and the `verify` command runs). To use your own Qwen server, open **⚙ Configure → QWEN COM CHAVE**, fill in name, address, model and key, and click *Testar e salvar*: Brito tests the connection before saving, stores the key encrypted by the OS vault (never in `config.json`) and creates the `qwen` profile. Only `https://` addresses are accepted (`http://` for localhost and private networks). A `qwen` profile you wrote by hand is never overwritten.
+
 - The implementer runs in an isolated context (it does not see the conversation), with the graph of the symbols passed in `focus`. Its edits and commands follow the permission mode, and in `claude` CLI mode they are approved in the terminal just like Claude's.
 - When it finishes, the tool itself appends `git status --short`, `git diff --stat` and the output of the task's `verify` command, so Claude judges by what changed on disk, not by the implementer's report.
 - `/orquestrar` shows the state; `/orquestrar off` turns it off; `/orquestrar modelo <profile>` picks another implementer profile (also `BRITO_IMPL_MODEL` or `implModel` in the config). They combine: `/orquestrar on modelo qwen`. With `--global`, what you asked for is saved in the config: `/orquestrar on --global` turns the mode on every time Brito starts (`orchestrator: true`), and `/orquestrar off --global` undoes it. The status bar shows `⚙ →qwen` while it is on. In the desktop app, use the "Implementa" picker.

package/dist/agent/claude-cli.js

@@ -7,6 +7,7 @@ import { skillsIndex } from "../skills/store.js";
 import { MCP_NAME, MCP_PREFIX, APPROVE_TOOL } from "../mcp/server.js";
 import { ui as terminalUi } from "../ui/ui.js";
 import { MODE_ENV, perms } from "../permissions.js";
+import { scrubbedEnv } from "../endpoint.js";
 import { CLAUDE_EDIT_TOOLS, ORCH_MCP_TIMEOUT, ORCH_NOTE, ORCH_NOTE_CLAUDE, orch, orchEnv } from "../orchestrator.js";
 import { DEFAULT_MODEL, wireEffort } from "../model.js";
 import { subagentModel } from "../engine.js";
@@ -260,7 +261,7 @@ export class ClaudeSession {
             const child = (this.child = spawn(cmd.command, cmd.args, {
                 cwd: this.o.root, stdio: ["ignore", "pipe", "pipe"],
                 // `/reasoning none`: o claude desliga o raciocínio com MAX_THINKING_TOKENS=0 (não há `--effort none`)
-                env: { ...process.env, ...this.o.env, BRITO_DEPTH: String(Number(process.env.BRITO_DEPTH ?? 0) + 1),
+                env: { ...scrubbedEnv(), ...this.o.env, BRITO_DEPTH: String(Number(process.env.BRITO_DEPTH ?? 0) + 1),
                     ...(orch.on && !process.env.MCP_TOOL_TIMEOUT ? { MCP_TOOL_TIMEOUT: ORCH_MCP_TIMEOUT } : {}), ...(wireEffort(this.effort).thinking ? {} : { MAX_THINKING_TOKENS: "0" }) },
             }));
             let buf = "", stderr = "", ok = true, interrupted = false;

package/dist/desktop/serve.js

@@ -29,9 +29,10 @@ import { indexProject } from "../graph/indexer.js";
 import { initialEffort, initialModel, isEffort, loadProfiles, MODEL_ALIASES } from "../model.js";
 import { NO_ANTHROPIC, fallbackStatus, learnerModel, openEngine } from "../engine.js";
 import { engineChip, activateFallback, chooseModel, cliShouldFallBack, fallbackWarning, newFallbackState, renderFallback, retryPrompt } from "../provider/fallback.js";
-import { contextWindowFor, resolveModel } from "../provider/resolve.js";
+import { ENDPOINT_KEY_ENV, endpointInfo, removeEndpoint, saveEndpoint } from "../endpoint.js";
+import { SLM_MODEL, contextWindowFor, resolveModel } from "../provider/resolve.js";
 import { PLAN_NOTE, perms } from "../permissions.js";
-import { ORCH_NOTE, implStatus, mainTools, orch, orchGuard, restoreOrch } from "../orchestrator.js";
+import { ORCH_NOTE, implStatus, initialImplModel, mainTools, orch, orchGuard, restoreOrch } from "../orchestrator.js";
 import { getSkill, listBuiltins, listPending, listSkills, skillsIndex } from "../skills/store.js";
 import { defaultComplete, recordOutcomes, reflect, shouldReflect } from "../skills/learn.js";
 import { claudeCliComplete } from "../skills/learn-cli.js";
@@ -395,7 +396,10 @@ export async function serveDesktop(root, resumeId) {
     let busy = false;
     restoreOrch(engine.model, (m) => emit({ t: "warn", msg: m }), (m) => emit({ t: "info", msg: m }));
     const panels = new Panels(root, graphRootFor(root), isHome);
-    const ready = () => emit({ t: "ready", engine: engine.kind, sessionId: engine.sessionId, model: engine.model, effort: engine.effort, mode: perms.mode, orch: orch.on, symbols: syms, notes, root, fallback: engine.fallback.active, chip: chipOf(engine.model, engine.fallback) });
+    // Perfil de endpoint (Qwen com chave): só aparece no seletor depois de configurado.
+    const endpointName = () => { const m = initialImplModel(); return m === SLM_MODEL ? "qwen" : m; };
+    const orchMode = () => (!orch.on ? "" : orch.model === SLM_MODEL ? "slm" : "endpoint");
+    const ready = () => emit({ t: "ready", engine: engine.kind, sessionId: engine.sessionId, model: engine.model, effort: engine.effort, mode: perms.mode, orch: orch.on, orchMode: orchMode(), endpointReady: implStatus(engine.model, endpointName(), process.env).ready, endpoint: endpointInfo(), symbols: syms, notes, root, fallback: engine.fallback.active, chip: chipOf(engine.model, engine.fallback) });
     ready();
     const rl = readline.createInterface({ input: process.stdin });
     const quit = async () => { closeApproval(); try {
@@ -517,16 +521,36 @@ export async function serveDesktop(root, resumeId) {
                     engine.effort = isEffort(m.effort) ? m.effort : "";
                 if (["manual", "auto", "plan", "bypass"].includes(m.mode))
                     perms.mode = m.mode;
-                // "on" liga o modo orquestrador (se o implementador estiver pronto); "" desliga.
+                // "" desliga; "slm" = Qwen3-4B nativo escreve o código; "endpoint" (ou "on", antigo) = perfil com chave.
                 if (m.orch === "")
                     orch.on = false;
-                else if (m.orch === "on") {
-                    const s = implStatus(engine.model, orch.model, process.env);
-                    if (s.ready)
+                else if (m.orch === "slm" || m.orch === "endpoint" || m.orch === "on") {
+                    const impl = m.orch === "slm" ? SLM_MODEL : endpointName();
+                    const s = implStatus(engine.model, impl, process.env);
+                    if (s.ready) {
+                        orch.model = impl;
                         orch.on = true;
-                    else
-                        sink.warn(`modo orquestrador não ligou: ${s.reason}`);
+                    }
+                    else {
+                        orch.on = false;
+                        sink.warn(`Não deu para usar ${m.orch === "slm" ? "o Qwen3-4B nativo" : "o Qwen com chave"} para escrever código: ${s.reason}. Quem escreve o código continua sendo o Claude (usa tokens).`);
+                    }
+                }
+                ready();
+                break;
+            }
+            // Endpoint próprio (Qwen com chave). A chave chega pelo stdin, vem do processo principal do app e nunca é emitida de volta.
+            case "endpoint": {
+                if (m.op === "key") {
+                    if (typeof m.key === "string" && m.key.trim())
+                        process.env[ENDPOINT_KEY_ENV] = m.key.trim();
+                    ready();
+                    break;
                 }
+                const r = m.op === "remove" ? removeEndpoint() : m.op === "save" ? await saveEndpoint({ baseURL: String(m.baseURL ?? ""), model: String(m.model ?? ""), label: String(m.label ?? ""), key: String(m.key ?? "") }) : { ok: false, msg: "operação desconhecida" };
+                if (m.op === "remove")
+                    orchGuard(engine.model, (w) => sink.warn(w));
+                emit({ t: "endpointResult", ok: r.ok, msg: r.msg });
                 ready();
                 break;
             }

package/dist/endpoint.js

@@ -0,0 +1,113 @@
+import { loadProfiles, updateConfig } from "./model.js";
+// Configuração do endpoint próprio (Qwen com chave) feita pelo app. O perfil vai para `providers` no config SEM a
+// chave; a chave mora só na memória do backend (variável abaixo) e, no app, cifrada pelo cofre do sistema.
+/** Nome do perfil criado pelo app: é o que o modo orquestrador usa por padrão como implementador. */
+export const ENDPOINT_NAME = "qwen";
+/** Variável com a chave. Fica só na memória do backend e é removida do ambiente dos comandos do agente. */
+export const ENDPOINT_KEY_ENV = "BRITO_ENDPOINT_KEY";
+/** Ambiente para comandos que o agente roda (bash): sem a chave do endpoint, que o modelo não precisa ver. */
+export function scrubbedEnv(env = process.env) {
+    const { [ENDPOINT_KEY_ENV]: _drop, ...rest } = env;
+    return rest;
+}
+/** localhost, loopback e redes privadas (10.x, 172.16–31.x, 192.168.x): onde `http://` não expõe a chave à internet. */
+export function isPrivateHost(host) {
+    const h = host.toLowerCase().replace(/^\[|\]$/g, "");
+    if (h === "localhost" || h === "::1" || h.endsWith(".localhost"))
+        return true;
+    const m = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(h);
+    if (!m)
+        return false;
+    const [a, b] = [Number(m[1]), Number(m[2])];
+    if (m.slice(1).some((x) => Number(x) > 255))
+        return false;
+    return a === 127 || a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168);
+}
+/** Só `https://`; `http://` apenas em máquina local ou rede privada. Sem usuário/senha na URL. */
+export function checkBaseURL(raw) {
+    let u;
+    try {
+        u = new URL(raw.trim());
+    }
+    catch {
+        return { ok: false, error: "endereço inválido: use algo como https://servidor/v1" };
+    }
+    if (u.protocol !== "https:" && u.protocol !== "http:")
+        return { ok: false, error: "o endereço precisa começar com https://" };
+    if (u.username || u.password)
+        return { ok: false, error: "não coloque usuário/senha no endereço: a chave vai no campo próprio" };
+    if (u.protocol === "http:" && !isPrivateHost(u.hostname))
+        return { ok: false, error: "http:// só é aceito em localhost ou rede privada; use https:// para endereços públicos" };
+    const url = (u.origin + u.pathname).replace(/\/+$/, "");
+    return { ok: true, url, host: u.host };
+}
+/** Uma chamada mínima (1 token) para provar endereço, modelo e chave antes de gravar qualquer coisa. Nunca devolve a chave. */
+export async function testEndpoint(baseURL, model, key, fetchImpl = fetch) {
+    try {
+        const res = await fetchImpl(`${baseURL}/chat/completions`, {
+            method: "POST",
+            // sem seguir redirecionamento: a chave só vai para o endereço que você digitou
+            redirect: "manual",
+            headers: { "content-type": "application/json", authorization: `Bearer ${key}` },
+            body: JSON.stringify({ model, messages: [{ role: "user", content: "ok" }], max_tokens: 1 }),
+            signal: AbortSignal.timeout(20_000),
+        });
+        await res.body?.cancel().catch(() => { });
+        if (res.ok)
+            return { ok: true, msg: "conexão ok" };
+        if (res.status === 401 || res.status === 403)
+            return { ok: false, msg: "o servidor recusou a chave (HTTP " + res.status + ")" };
+        if (res.status === 404)
+            return { ok: false, msg: "não achei o endpoint: confira o endereço (geralmente termina em /v1) e o nome do modelo" };
+        if (res.status >= 300 && res.status < 400)
+            return { ok: false, msg: "o endereço redireciona para outro lugar; use o endereço final" };
+        return { ok: false, msg: `o servidor respondeu HTTP ${res.status}` };
+    }
+    catch (e) {
+        return { ok: false, msg: `não consegui falar com o servidor: ${e?.cause?.code ?? e?.message ?? e}` };
+    }
+}
+/** Valida, testa e só então grava o perfil (sem a chave). A chave fica em `process.env` desta sessão. */
+export async function saveEndpoint(f, opts = {}) {
+    const env = opts.env ?? process.env;
+    const model = f.model.trim(), key = f.key.trim(), label = f.label.trim() || "Qwen (endpoint)";
+    if (!model || !key || !f.baseURL.trim())
+        return { ok: false, msg: "preencha endereço, modelo e chave" };
+    const u = checkBaseURL(f.baseURL);
+    if (!u.ok)
+        return { ok: false, msg: u.error };
+    // não pisa num perfil `qwen` que o usuário escreveu à mão (com outra variável de chave)
+    const existing = loadProfiles().profiles[ENDPOINT_NAME];
+    if (existing && existing.apiKeyEnv !== ENDPOINT_KEY_ENV)
+        return { ok: false, msg: `já existe um perfil "${ENDPOINT_NAME}" no ~/.brito/config.json configurado à mão; edite-o por lá` };
+    const t = await testEndpoint(u.url, model, key, opts.fetchImpl);
+    if (!t.ok)
+        return t;
+    updateConfig((cfg) => {
+        cfg.providers = { ...(cfg.providers ?? {}), [ENDPOINT_NAME]: { type: "openai", baseURL: u.url, model, apiKeyEnv: ENDPOINT_KEY_ENV, label } };
+    });
+    env[ENDPOINT_KEY_ENV] = key;
+    return { ok: true, msg: `${label} · ${u.host} pronto` };
+}
+/** Remove o perfil criado pelo app (nunca um escrito à mão) e a chave da memória. */
+export function removeEndpoint(env = process.env) {
+    const existing = loadProfiles().profiles[ENDPOINT_NAME];
+    if (existing && existing.apiKeyEnv === ENDPOINT_KEY_ENV) {
+        updateConfig((cfg) => { if (cfg.providers)
+            delete cfg.providers[ENDPOINT_NAME]; });
+    }
+    delete env[ENDPOINT_KEY_ENV];
+    return { ok: true, msg: "endpoint removido" };
+}
+/** Rótulo e host do endpoint configurado pelo app, para a tela mostrar (sem chave). */
+export function endpointInfo() {
+    const p = loadProfiles().profiles[ENDPOINT_NAME];
+    if (!p || p.apiKeyEnv !== ENDPOINT_KEY_ENV)
+        return null;
+    try {
+        return { label: p.label, host: new URL(p.baseURL).host };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/model.js

@@ -1,4 +1,4 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 /** Atalhos para os modelos atuais (o Hermes resolve aliases antes de validar o nome). */
@@ -19,16 +19,24 @@ export function loadSavedModel() {
         return undefined;
     }
 }
-/** Grava `patch` no config global preservando as demais chaves. */
-function saveConfig(patch) {
+/**
+ * Altera o config global preservando as demais chaves. Grava num arquivo temporário e renomeia: uma queda no meio da
+ * escrita não deixa o config pela metade (ele guarda também modelo, esforço e perfis).
+ */
+export function updateConfig(mutate) {
     let cfg = {};
     try {
         cfg = JSON.parse(readFileSync(configPath(), "utf8")) ?? {};
     }
     catch { /* config novo ou ilegível */ }
+    mutate(cfg);
     mkdirSync(dirname(configPath()), { recursive: true });
-    writeFileSync(configPath(), JSON.stringify({ ...cfg, ...patch }, null, 2) + "\n");
+    const tmp = `${configPath()}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(cfg, null, 2) + "\n");
+    renameSync(tmp, configPath());
 }
+/** Grava `patch` no config global preservando as demais chaves. */
+const saveConfig = (patch) => updateConfig((cfg) => Object.assign(cfg, patch));
 export const saveModel = (model) => saveConfig({ model });
 /** Perfil que implementa as tasks no modo orquestrador (`implModel` no config). */
 export function loadSavedImplModel() {

package/dist/orchestrator.js

@@ -1,7 +1,9 @@
 import { allTools } from "./tools/registry.js";
 import { loadProfiles, loadSavedImplModel, loadSavedOrch } from "./model.js";
 import { missingKeyMessage } from "./provider/openai-compat.js";
-import { resolveModel } from "./provider/resolve.js";
+import { resolveModel, SLM_MODEL } from "./provider/resolve.js";
+import { slmReadySync } from "./local/slm.js";
+import { ENDPOINT_KEY_ENV } from "./endpoint.js";
 // Modo orquestrador: o modelo principal (Claude) planeja e revisa; um perfil de endpoint (o qwen) implementa cada task
 // pela tool `implement`. Estado global da sessão, como o `perms`.
 /** Prioridade: BRITO_IMPL_MODEL > config global (`implModel`) > qwen. */
@@ -34,6 +36,9 @@ export function implStatus(main, impl, env) {
         return { ready: false, reason: `o perfil "${name}" em ~/.brito/config.json está inválido (${why})` };
     }
     const p = profiles[name];
+    // SLM nativo do Brito (Qwen3-4B): roda na máquina, não tem chave; basta estar baixado.
+    if (!p && name === SLM_MODEL)
+        return slmReadySync() ? { ready: true, label: "Qwen3-4B (nativo)" } : { ready: false, reason: "o SLM nativo não está pronto: rode `brito slm pull`" };
     if (!p || resolveModel(name).kind !== "openai")
         return { ready: false, reason: `sem perfil "${name}" em providers no ~/.brito/config.json` };
     if (!env[p.apiKeyEnv]?.trim())
@@ -71,7 +76,13 @@ export function restoreOrch(main, warn, info) {
 /** O servidor MCP roda em outro processo (subido pelo claude CLI a cada turno): o modo e o perfil chegam pelo env. */
 export const ORCH_ENV = "BRITO_ORCH";
 /** Env do servidor MCP: liga a tool `implement` lá e diz qual perfil implementa. */
-export const orchEnv = () => (orch.on ? { [ORCH_ENV]: "1", BRITO_IMPL_MODEL: orch.model } : {});
+export const orchEnv = () => {
+    if (!orch.on)
+        return {};
+    // a chave do endpoint vai só ao servidor MCP (que roda o implementador), não ao ambiente do claude e dos comandos dele
+    const key = process.env[ENDPOINT_KEY_ENV];
+    return { [ORCH_ENV]: "1", BRITO_IMPL_MODEL: orch.model, ...(key ? { [ENDPOINT_KEY_ENV]: key } : {}) };
+};
 /** Uma task do implementador leva minutos: o timeout padrão do claude CLI para tools MCP cortaria no meio (30 min). */
 export const ORCH_MCP_TIMEOUT = "1800000";
 /** Tools nativas do claude CLI que editam arquivos: bloqueadas com o modo ligado. */

package/dist/tools/bash.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { exec } from "node:child_process";
 import { defineTool } from "./registry.js";
 import { shellFor } from "../util/platform.js";
+import { scrubbedEnv } from "../endpoint.js";
 defineTool({
     name: "bash",
     description: "Executa um comando shell na raiz do projeto (timeout padrão 120s).",
@@ -10,7 +11,7 @@ defineTool({
     mutates: true,
     describe: (i) => i.command,
     run: ({ command, timeout_ms = 120_000 }, { root }) => new Promise((resolve) => {
-        exec(command, { cwd: root, shell: shellFor(), timeout: timeout_ms, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+        exec(command, { cwd: root, shell: shellFor(), env: scrubbedEnv(), timeout: timeout_ms, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
             const out = (stdout + (stderr ? `\n[stderr]\n${stderr}` : "")).trim();
             resolve(`${err ? `[exit ${err.code ?? "?"}] ` : ""}${out.slice(-30_000) || "(sem saída)"}`);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Coding-agent CLI with a code knowledge graph, memory and reviewable skills / CLI de agente de código com grafo de conhecimento, memória e skills revisáveis",
   "type": "module",
   "bin": {