omnispace 0.15.1 → 0.17.0

package/dist/auto-sync.js

@@ -0,0 +1,99 @@
+import { callApi } from "./api.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+import { buildManifest } from "./include.js";
+import { unresolvedConflicts } from "./conflicts.js";
+import { readJournal } from "./journal.js";
+import { pullSpace, remoteMap } from "./pull.js";
+import { pushSpace } from "./sync.js";
+import { LockedError, withLock } from "./lock.js";
+import { loadToken, readSpaceConfig } from "./config.js";
+import { statusSpace, summarizeStatus } from "./status.js";
+/** What to do given the three-way summary. A file changed on both sides stops everything. */
+export function planAuto(summary, head, baseVersion, pullOnly) {
+    if (summary.both.length > 0)
+        return { kind: "diverged", files: summary.both };
+    const pull = head > baseVersion;
+    const push = !pullOnly && summary.local.length > 0;
+    return pull || push ? { kind: "sync", pull, push } : { kind: "nothing" };
+}
+/** Runs `fn` with console output captured: pull and push talk a lot, a hook must say one line. */
+async function captured(fn) {
+    const lines = [];
+    const saved = { log: console.log, error: console.error };
+    const grab = (...args) => void lines.push(args.join(" "));
+    console.log = grab;
+    console.error = grab;
+    try {
+        const code = await fn();
+        const last = [...lines].reverse().map((l) => l.trim()).find((l) => l.length > 0) ?? "";
+        return { code, last };
+    }
+    finally {
+        console.log = saved.log;
+        console.error = saved.error;
+    }
+}
+async function autoOnce(root, opts, deps) {
+    const config = await readSpaceConfig(root);
+    if (!config?.spaceId)
+        return null;
+    const token = await loadToken(config.apiUrl);
+    if (!token)
+        return "CLI sem sessão nesta máquina; rode omnispace login (sync automático parado).";
+    const [journal, markers] = await Promise.all([readJournal(root), unresolvedConflicts(root, { readOnly: true })]);
+    if (journal)
+        return "um pull parou no meio; rode omnispace sync --pull.";
+    if (markers.length > 0)
+        return `${markers.length} arquivo(s) com marcador de conflito; resolva antes do sync automático.`;
+    const manifest = await buildManifest(root);
+    if (manifest.truncated)
+        return "pasta grande demais para o sync automático.";
+    const res = await callApi(config.apiUrl, token, "/api/cli/sync/status", { spaceId: config.spaceId, baseVersion: config.baseVersion }, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!res.ok)
+        return `servidor não consultado (${res.error}); sync automático adiado.`;
+    const head = res.head;
+    const headMap = remoteMap(res.files);
+    const baseMap = res.base ? remoteMap(res.base) : headMap;
+    const local = new Map(manifest.files.map((f) => [f.path, f.hash]));
+    const skip = (path) => manifest.unreadable.some((u) => path === u || path.startsWith(`${u}/`));
+    const readable = (map) => new Map([...map].filter(([path]) => !skip(path)));
+    const summary = summarizeStatus(local, readable(baseMap), readable(headMap));
+    const plan = planAuto(summary, head, config.baseVersion, Boolean(opts.pullOnly));
+    if (plan.kind === "nothing")
+        return null;
+    if (plan.kind === "diverged") {
+        return `${plan.files.length} arquivo(s) mudado(s) nesta pasta e no servidor (${plan.files.slice(0, 3).join(", ")}); sync automático parado, rode omnispace sync --pull para decidir.`;
+    }
+    const parts = [];
+    if (plan.pull) {
+        // conflito: "backup" only matters if a race creates a conflict after the check: it keeps both.
+        const r = await captured(() => deps.pull(root, { conflito: "backup" }));
+        if (r.code !== 0)
+            return `pull automático não terminou: ${r.last || "erro sem mensagem"}`;
+        if (summary.remote > 0)
+            parts.push(`trouxe ${summary.remote} arquivo(s) do servidor`);
+    }
+    if (plan.push) {
+        const r = await captured(() => deps.push(root, { yes: true }));
+        if (r.code !== 0)
+            return `${parts.length ? `${parts.join(", ")}; ` : ""}envio automático não feito: ${r.last || "erro sem mensagem"}`;
+        const after = await readSpaceConfig(root);
+        parts.push(`enviei ${summary.local.length} arquivo(s)${after ? ` (versão ${after.baseVersion})` : ""}`);
+    }
+    return parts.length > 0 ? parts.join(", ") : null;
+}
+export async function syncAuto(root, opts = {}, deps = { pull: pullSpace, push: pushSpace }) {
+    try {
+        const line = await withLock(root, () => autoOnce(root, opts, deps));
+        if (line)
+            console.log(`Omni: sync automático: ${line}`);
+    }
+    catch (err) {
+        // Another sync (another agent in the same folder) holds the lock: it does the work.
+        if (!(err instanceof LockedError))
+            console.log(`Omni: sync automático falhou (${err.message.slice(0, 160)}).`);
+    }
+    if (opts.resumo)
+        await statusSpace(root, { resumo: true });
+    return 0;
+}

package/dist/confirmar.js

@@ -0,0 +1,96 @@
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { callApi } from "./api.js";
+import { loadToken, readSpaceConfig } from "./config.js";
+import { terminalSafe } from "./ask.js";
+// `omnispace confirmar [pedido] [pasta]` (ADR 009, item 5 da fatia 1 do MCP): a pessoa vê o pedido
+// pendente inteiro (0033) e decide s/n no terminal. Sem ferramenta de confirmar pelo MCP — um pedido
+// registrado por `omni_pedir` só sai do estado "pendente" por aqui, inclusive de dentro do Claude
+// Code com `! omnispace confirmar`.
+export const CONFIRMAR_USAGE = "Uso: omnispace confirmar [pedido] [pasta]";
+async function askTerminal(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await rl.question(question);
+    }
+    finally {
+        rl.close();
+    }
+}
+const hhmm = (iso) => {
+    const d = new Date(iso);
+    return Number.isNaN(d.getTime()) ? iso : d.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" });
+};
+function formatPendingRow(p) {
+    const out = [`Pedido ${terminalSafe(p.ref)}, aguardando decisão (vale até ${hhmm(p.expiresAt)}):`, `  ${terminalSafe(p.connectorId)}: ${terminalSafe(p.actionKey)}`];
+    const input = p.input && typeof p.input === "object" && !Array.isArray(p.input) ? p.input : { entrada: p.input };
+    for (const [key, value] of Object.entries(input)) {
+        const line = typeof value === "string" ? value : JSON.stringify(value);
+        out.push(`    ${terminalSafe(key)}: ${terminalSafe(line ?? "")}`);
+    }
+    if (Object.keys(input).length === 0)
+        out.push("    (sem entrada)");
+    return out;
+}
+export async function confirmarSpace(args, opts = {}) {
+    const folder = resolve(args.folder);
+    const config = await readSpaceConfig(folder);
+    if (!config?.spaceId) {
+        console.log(`\n${folder} não tem um espaço Omni com conta criada. Rode de dentro da pasta do espaço.\n`);
+        return 1;
+    }
+    const token = await loadToken(config.apiUrl);
+    if (!token) {
+        console.log(`\nNenhuma sessão da CLI nesta máquina para ${config.apiUrl}. Rode: omnispace login\n`);
+        return 1;
+    }
+    const list = await callApi(config.apiUrl, token, "/api/cli/actions/pending", { spaceId: config.spaceId });
+    if (!list.ok) {
+        console.log(`\nNão foi possível listar os pedidos: ${terminalSafe(String(list.error))}\n`);
+        return 1;
+    }
+    const pending = list.pending ?? [];
+    if (pending.length === 0) {
+        console.log("\nNenhum pedido em aberto neste espaço.\n");
+        return 0;
+    }
+    const targets = args.pedido ? pending.filter((p) => p.ref === args.pedido || p.id === args.pedido) : pending;
+    if (args.pedido && targets.length === 0) {
+        console.log(`\nPedido "${args.pedido}" não encontrado (decidido ou vencido). Em aberto:`);
+        for (const p of pending)
+            console.log(`  ${p.ref}  ${p.connectorId}: ${p.actionKey}`);
+        console.log("");
+        return 1;
+    }
+    const interactive = opts.interactive ?? Boolean(process.stdin.isTTY);
+    const ask = opts.ask ?? askTerminal;
+    let failed = false;
+    for (const p of targets) {
+        console.log("");
+        for (const line of formatPendingRow(p))
+            console.log(line);
+        if (!interactive) {
+            console.log("  Sem terminal para confirmar. Rode de novo num terminal.");
+            failed = true;
+            continue;
+        }
+        const answer = (await ask("  Executar? [s/n] ")).trim().toLowerCase();
+        const decision = answer === "s" || answer === "sim" ? "s" : "n";
+        const res = await callApi(config.apiUrl, token, "/api/cli/actions/confirm", { spaceId: config.spaceId, requestId: p.id, decision });
+        if (decision === "n") {
+            console.log(res.ok ? "  Recusado. Nada foi executado." : `  ${terminalSafe(String(res.error))}`);
+            continue;
+        }
+        if (res.ok) {
+            console.log("  ✓ Executado.");
+            if (typeof res.output === "string")
+                console.log(`  Resultado: ${terminalSafe(res.output)}`);
+        }
+        else {
+            console.log(`  ✗ Não executado: ${terminalSafe(String(res.error))}`);
+            failed = true;
+        }
+    }
+    console.log("");
+    return failed ? 1 : 0;
+}

package/dist/hooks.js

@@ -0,0 +1,90 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+// Hooks do Claude Code que mantêm a pasta em dia sem a pessoa pedir (checklist 2 de
+// docs/plan/visao-jarvis-automacao-2026-09-28.md). Vão em `.claude/settings.json`, que sincroniza
+// entre máquinas: os comandos são iguais em qualquer sistema, ao contrário dos arquivos de MCP.
+//   SessionStart: `omnispace sync --auto --pull-only --resumo` (traz o que chegou e diz o estado;
+//                 troca o `omnispace status --resumo` antigo, que rodaria em paralelo e leria o estado velho)
+//   SessionEnd:   `omnispace sync --auto` (traz e envia o que mudou, sem conflito)
+export const START_COMMAND = "omnispace sync --auto --pull-only --resumo";
+export const END_COMMAND = "omnispace sync --auto";
+const OLD_START = /^\s*(omnispace|omni)\s+status\s+--resumo\s*$/;
+function hasCommand(groups, test) {
+    return groups.some((g) => (g.hooks ?? []).some((h) => typeof h.command === "string" && test(h.command)));
+}
+/** Pure merge: returns the new settings and whether anything changed. Never removes another hook. */
+export function mergeHooks(settings) {
+    const next = { ...settings, hooks: { ...(settings.hooks ?? {}) } };
+    const hooks = next.hooks;
+    let changed = false;
+    const start = (hooks.SessionStart ?? []).map((g) => ({ ...g, hooks: (g.hooks ?? []).map((h) => ({ ...h })) }));
+    if (!hasCommand(start, (c) => c.includes("sync --auto"))) {
+        let replaced = false;
+        for (const group of start) {
+            for (const h of group.hooks ?? []) {
+                if (typeof h.command === "string" && OLD_START.test(h.command)) {
+                    h.command = START_COMMAND;
+                    replaced = true;
+                }
+            }
+        }
+        if (!replaced)
+            start.push({ matcher: "startup|resume", hooks: [{ type: "command", command: START_COMMAND, timeout: 90 }] });
+        hooks.SessionStart = start;
+        changed = true;
+    }
+    const end = (hooks.SessionEnd ?? []).map((g) => ({ ...g, hooks: (g.hooks ?? []).map((h) => ({ ...h })) }));
+    if (!hasCommand(end, (c) => c.includes("sync --auto"))) {
+        end.push({ hooks: [{ type: "command", command: END_COMMAND, timeout: 90 }] });
+        hooks.SessionEnd = end;
+        changed = true;
+    }
+    return { next, changed };
+}
+/** `.claude/settings.json` of the folder. Unreadable (comments, broken JSON): untouched, reported. */
+export async function installHooks(folder) {
+    const path = join(folder, ".claude", "settings.json");
+    let settings = {};
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch {
+        raw = undefined;
+    }
+    if (raw !== undefined) {
+        try {
+            settings = JSON.parse(raw);
+        }
+        catch {
+            return { path, changed: false, skipped: true };
+        }
+    }
+    const { next, changed } = mergeHooks(settings);
+    if (!changed)
+        return { path, changed: false, skipped: false };
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    await rename(tmp, path);
+    return { path, changed: true, skipped: false };
+}
+// Depois de sync, clone, vincular e init (junto do MCP): liga os hooks sozinho na pasta de espaço.
+// Só fala quando mudou algo; `OMNI_NO_HOOKS=1` desliga.
+export async function autoWireHooks(folder) {
+    if (process.env.OMNI_NO_HOOKS)
+        return;
+    try {
+        if (!(await readFile(join(folder, ".omni", "space.json"), "utf8").then(() => true, () => false)))
+            return;
+        const r = await installHooks(folder);
+        if (r.changed) {
+            console.log(`\nSync automático ligado nos hooks do Claude Code (${r.path}): traz o que chegou ao abrir a sessão e envia o que mudou ao fechar. Conflito nunca é forçado.`);
+        }
+        if (r.skipped)
+            console.log(`\nNão mexi em ${r.path} (comentários ou JSON quebrado). Para ligar o sync automático, adicione os hooks à mão: rode omnispace hooks instalar depois de corrigir o arquivo.`);
+    }
+    catch {
+        // ligar os hooks nunca derruba o comando que a pessoa rodou
+    }
+}

package/dist/include.js

@@ -70,9 +70,10 @@ export function isSecret(name) {
  * Settings of a tool on this machine that happen to live in the folder: Claude Code keeps
  * permissions and local choices in `.claude/settings.local.json` (the shared `settings.json`
  * does sync). Out of the sync since 2026-09-27 (Lucas, P1 fatia 2); it can carry values
- * specific to one machine.
+ * specific to one machine. Same for the MCP config of each editor (`.mcp.json`, `.cursor/`, `.vscode/`, `.trae/`):
+ * it holds this machine's command (`cmd /c omni` on Windows), so each machine runs `omnispace mcp instalar`.
  */
-const MACHINE_CONFIG_RE = /(^|\/)\.claude\/settings\.local\.json$/i;
+const MACHINE_CONFIG_RE = /(^|\/)(\.claude\/settings\.local\.json|\.mcp\.json|\.(cursor|vscode|trae)\/mcp\.json|\.zed\/settings\.json|\.codex\/config\.toml)$/i;
 export function isMachineConfig(path) {
     return MACHINE_CONFIG_RE.test(path);
 }

package/dist/index.js

@@ -21,33 +21,42 @@ import { runEnv } from "./env.js";
 import { runPermissoes } from "./permissoes.js";
 import { runUso } from "./uso.js";
 import { runLlm } from "./llm.js";
-const USAGE = `
-Omni CLI
-
-Uso:
-  omni login                        entra na sua conta pelo navegador (a sessão vale 14 dias sem uso)
-  omni logout                       encerra a sessão da CLI nesta máquina
-  omni whoami                       mostra a conta, a máquina e até quando a sessão vale
-  omni init [pasta] [--nome <nome>] com a CLI logada, cria o espaço na sua conta e liga a pasta
-  omni init [pasta] --scan-only     varre a pasta e mostra o que encontrou
-  omni init [pasta] --link <código> varre a pasta e envia pro código mostrado no navegador
-  omni status [pasta] [--resumo]    o que mudou aqui e no servidor, e o próximo comando (só lê)
-  omni ask "<pergunta>" [pasta]     responde com base na versão publicada do espaço, com as fontes
-        [--fontes]                  só mostra quais arquivos seriam lidos, sem chamar o modelo
-        [--detalhes]                mostra também custo, contexto e arquivos consultados
-  omni sync [pasta] --push [--yes]  publica uma nova versão do espaço no servidor
-  omni sync [pasta] --pull          traz para a pasta a versão mais nova do servidor
-        [--conflito=local|mesclar|backup]  mesma resposta para todos os conflitos, sem perguntar
-  omni clone <código> <pasta>       baixa um espaço da sua conta numa pasta nova desta máquina
-  omni vincular [pasta] [--espaco <nome>]  liga uma pasta que já tem os arquivos a um espaço da conta
-  omni desvincular [pasta]          tira esta máquina da conta e o .omni/ das pastas (pede 2 confirmações)
-  omni env push|list|rm [pasta]     guarda chaves do .env no cofre do espaço, uma a uma (confirma no navegador)
-  omni permissoes [set <conector> <ação> <estado>] [pasta]  o que o agente pode fazer sozinho em cada ação
-  omni uso                          tokens e custo de modelo da sua conta hoje e no mês, por rota e por chave
-  omni llm [set anthropic|rm]       usar a sua chave da Anthropic no lugar do modelo do Omni, com teto diário
-
-A CLI não reorganiza a sua pasta. Com --link, o que fazer com o que foi
-varrido é decidido na tela de revisão, no navegador.
+import { confirmarSpace } from "./confirmar.js";
+import { syncAuto } from "./auto-sync.js";
+import { autoWireHooks, installHooks } from "./hooks.js";
+import { autoWireMcp, detectEditors, installMcpConfig, mcpNextSteps, mcpSkippedNote, runMcpServer } from "./mcp.js";
+const USAGE = `
+Omni CLI
+
+Uso:
+  omni login                        entra na sua conta pelo navegador (a sessão vale 14 dias sem uso)
+  omni logout                       encerra a sessão da CLI nesta máquina
+  omni whoami                       mostra a conta, a máquina e até quando a sessão vale
+  omni init [pasta] [--nome <nome>] com a CLI logada, cria o espaço na sua conta e liga a pasta
+  omni init [pasta] --scan-only     varre a pasta e mostra o que encontrou
+  omni init [pasta] --link <código> varre a pasta e envia pro código mostrado no navegador
+  omni status [pasta] [--resumo]    o que mudou aqui e no servidor, e o próximo comando (só lê)
+  omni ask "<pergunta>" [pasta]     responde com base na versão publicada do espaço, com as fontes
+        [--fontes]                  só mostra quais arquivos seriam lidos, sem chamar o modelo
+        [--detalhes]                mostra também custo, contexto e arquivos consultados
+  omni sync [pasta] --push [--yes]  publica uma nova versão do espaço no servidor
+  omni sync [pasta] --pull          traz para a pasta a versão mais nova do servidor
+        [--conflito=local|mesclar|backup]  mesma resposta para todos os conflitos, sem perguntar
+  omni clone <código> <pasta>       baixa um espaço da sua conta numa pasta nova desta máquina
+  omni vincular [pasta] [--espaco <nome>]  liga uma pasta que já tem os arquivos a um espaço da conta
+  omni desvincular [pasta]          tira esta máquina da conta e o .omni/ das pastas (pede 2 confirmações)
+  omni env push|list|rm [pasta]     guarda chaves do .env no cofre do espaço, uma a uma (confirma no navegador)
+  omni permissoes [set <conector> <ação> <estado>] [pasta]  o que o agente pode fazer sozinho em cada ação
+  omni uso                          tokens e custo de modelo da sua conta hoje e no mês, por rota e por chave
+  omni llm [set anthropic|rm]       usar a sua chave da Anthropic no lugar do modelo do Omni, com teto diário
+  omni mcp                          servidor MCP local (stdio) pro Claude Code e pro Cursor lerem este espaço
+  omni mcp instalar [pasta]         acrescenta o servidor omni ao MCP do Claude Code, Cursor (e VS Code, Trae se a pasta usa) (mescla, nunca apaga outro)
+  omni sync [pasta] --auto [--pull-only] [--resumo]  o que os hooks rodam: traz e envia sem perguntar, para se houver conflito
+  omni hooks instalar [pasta]       liga o sync automático nos hooks do Claude Code da pasta (mescla, nunca apaga outro)
+  omni confirmar [pedido] [pasta]   decide s/n um pedido pendente de escrita, visto por inteiro no terminal
+
+A CLI não reorganiza a sua pasta. Com --link, o que fazer com o que foi
+varrido é decidido na tela de revisão, no navegador.
 `;
 async function main(argv) {
     const args = argv.slice(2);
@@ -67,10 +76,20 @@ async function main(argv) {
         return logout();
     if (command === "whoami")
         return printWhoami();
-    if (command === "sync")
-        return runSync(args.slice(1));
-    if (command === "clone")
-        return runClone(args.slice(1));
+    if (command === "sync") {
+        const rest = args.slice(1);
+        if (rest.includes("--auto")) {
+            return syncAuto(resolve(rest.find((a) => !a.startsWith("-")) ?? process.cwd()), {
+                pullOnly: rest.includes("--pull-only"),
+                resumo: rest.includes("--resumo"),
+            });
+        }
+        return withMcp(await runSync(rest), resolve(rest.find((a) => !a.startsWith("-")) ?? process.cwd()));
+    }
+    if (command === "clone") {
+        const rest = args.slice(1);
+        return withMcp(await runClone(rest), resolve(rest.filter((a) => !a.startsWith("-"))[1] ?? process.cwd()));
+    }
     if (command === "env")
         return runEnv(args.slice(1), { openBrowser: process.stdout.isTTY });
     if (command === "permissoes")
@@ -79,12 +98,51 @@ async function main(argv) {
         return runUso(args.slice(1));
     if (command === "llm")
         return runLlm(args.slice(1), { openBrowser: process.stdout.isTTY });
+    if (command === "mcp") {
+        const rest = args.slice(1);
+        if (rest[0] === "instalar") {
+            const folder = resolve(rest.slice(1).find((a) => !a.startsWith("-")) ?? process.cwd());
+            const editors = await detectEditors(folder); // antes de instalar: o install cria .cursor/
+            const { paths, alreadyThere, skipped } = await installMcpConfig(folder);
+            const onde = paths.map((p) => `  ${p}`).join("\n");
+            const passos = mcpNextSteps(editors);
+            console.log(`\n${alreadyThere ? "Atualizado" : "Servidor omni acrescentado"} em:\n${onde}\n\n${passos}\nWindsurf só lê o arquivo global do usuário (~/.codeium/windsurf/mcp_config.json): cole lá a entrada de .mcp.json.\n`);
+            if (skipped.length)
+                console.log(mcpSkippedNote(skipped));
+            return 0;
+        }
+        return runMcpServer(process.cwd());
+    }
+    if (command === "hooks") {
+        const rest = args.slice(1);
+        if (rest[0] !== "instalar") {
+            console.error("Use omnispace hooks instalar [pasta].");
+            return 1;
+        }
+        const folder = resolve(rest.slice(1).find((a) => !a.startsWith("-")) ?? process.cwd());
+        const r = await installHooks(folder);
+        console.log(r.skipped ? `
+Não mexi em ${r.path}: comentários ou JSON quebrado. Corrija e rode de novo.
+` : r.changed ? `
+Hooks de sync automático ligados em ${r.path}.
+` : `
+Os hooks já estavam em ${r.path}.
+`);
+        return r.skipped ? 1 : 0;
+    }
+    if (command === "confirmar") {
+        const rest = args.slice(1);
+        const pedido = rest.find((a) => !a.startsWith("-"));
+        const folder = rest.filter((a) => !a.startsWith("-"))[1] ?? process.cwd();
+        return confirmarSpace({ pedido, folder });
+    }
     if (command === "vincular") {
         const rest = args.slice(1);
         const espacoIndex = rest.indexOf("--espaco");
         const espaco = rest.find((a) => a.startsWith("--espaco="))?.slice("--espaco=".length) ?? (espacoIndex >= 0 ? rest[espacoIndex + 1] : undefined);
         const folder = rest.find((a, i) => !a.startsWith("-") && (espacoIndex < 0 || i !== espacoIndex + 1));
-        return linkExistingSpace(folder ?? process.cwd(), { espaco, yes: rest.includes("--yes") }, process.stdin.isTTY ? terminalAsk : null);
+        const linked = await linkExistingSpace(folder ?? process.cwd(), { espaco, yes: rest.includes("--yes") }, process.stdin.isTTY ? terminalAsk : null);
+        return withMcp(linked, resolve(folder ?? process.cwd()));
     }
     if (command === "desvincular")
         return unlinkMachine(resolve(args.slice(1).find((a) => !a.startsWith("-")) ?? process.cwd()));
@@ -126,20 +184,20 @@ async function main(argv) {
             if (!who.ok && !who.noToken)
                 console.error(`\n${who.error}`);
             const site = defaultApiUrl();
-            console.log(`
-Omni CLI
-
-Já tem conta no Omni? Entre por aqui e rode o init de novo:
-  npx -y omnispace@latest login
-
-Primeira vez? Comece pelo navegador:
-  ${site}/omnispace/escolha
-
-Lá aparece um código (tipo ABCD-2345). Com ele, dentro da pasta do espaço, rode:
-  npx -y omnispace@latest init . --link <código>
-
-Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
-  npx -y omnispace@latest init . --scan-only
+            console.log(`
+Omni CLI
+
+Já tem conta no Omni? Entre por aqui e rode o init de novo:
+  npx -y omnispace@latest login
+
+Primeira vez? Comece pelo navegador:
+  ${site}/omnispace/escolha
+
+Lá aparece um código (tipo ABCD-2345). Com ele, dentro da pasta do espaço, rode:
+  npx -y omnispace@latest init . --link <código>
+
+Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
+  npx -y omnispace@latest init . --scan-only
 `);
             return who.ok || who.noToken ? 0 : 1;
         }
@@ -163,7 +221,7 @@ Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
         return 1;
     }
     if (me)
-        return initWithAccount(target, me, { name: nameArg, yes: rest.includes("--yes") });
+        return withMcp(await initWithAccount(target, me, { name: nameArg, yes: rest.includes("--yes") }), target);
     const scan = await scanFolder(target);
     printScanReport(scan, { linking: Boolean(linkCode) });
     if (linkCode && scan.truncated) {
@@ -179,6 +237,13 @@ Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
         await linkAndSubmit(linkCode, target, scan);
     return 0;
 }
+async function withMcp(code, folder) {
+    if (code === 0) {
+        await autoWireMcp(folder);
+        await autoWireHooks(folder);
+    }
+    return code;
+}
 async function runSync(rest) {
     const push = rest.includes("--push");
     const pull = rest.includes("--pull");

package/dist/llm.js

@@ -1,9 +1,11 @@
 import { resolve } from "node:path";
 import { createInterface } from "node:readline";
+import { createInterface as createPromptInterface } from "node:readline/promises";
 import { callApi } from "./api.js";
 import { defaultApiUrl, loadToken } from "./config.js";
 import { context, refused, verify } from "./env.js";
 import { RETRY_DELAYS_MS } from "./retry.js";
+import { maskValue, readEnvVars } from "./dotenv.js";
 // `omnispace llm` (docs/plan/byok-e-medicao.md): the person's own LLM key. With it on, questions
 // run on their model and the cost comes out of their provider account, up to a daily ceiling in
 // US$ checked before each call. The key is typed hidden (never an argument: it would stay in the
@@ -14,7 +16,8 @@ export const LLM_USAGE = `Uso:
   omnispace llm set anthropic [--modelo haiku|sonnet] [--teto <US$ por dia>] [pasta]
                                                       liga a sua chave da Anthropic (pedida escondida no terminal)
   omnispace llm rm [pasta]                            apaga a sua chave; as perguntas voltam para o modelo do Omni
-Gravar e apagar a chave pedem confirmação no navegador. Padrão: haiku, teto de US$ 2 por dia.`;
+Gravar e apagar a chave pedem confirmação no navegador. Padrão: haiku, teto de US$ 2 por dia.
+Mais seguro que colar no terminal: ponha ANTHROPIC_API_KEY no .env da pasta; a CLI mostra só os 4 últimos caracteres e pergunta.`;
 export function formatLlmStatus(s) {
     if (!s.provider) {
         return [
@@ -29,22 +32,57 @@ export function formatLlmStatus(s) {
     out.push(s.engine === "pessoa" ? "As suas perguntas rodam na sua chave." : "As suas perguntas rodam no modelo do Omni.");
     return out;
 }
-/** Reads a line without echoing it: the key never appears on screen. */
+/**
+ * Reads a line without echoing it: the key never appears on screen. The question goes out through
+ * readline itself and only then is the output muted (Lucas, 2026-09-28: written before the prompt,
+ * readline's line refresh erased it and the terminal looked stuck).
+ */
+async function askLine(question) {
+    const rl = createPromptInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
 function askHidden(question) {
     return new Promise((done) => {
         const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-        const write = rl._writeToOutput;
-        process.stdout.write(question);
-        rl._writeToOutput = () => { };
-        rl.question("", (answer) => {
-            if (write)
-                rl._writeToOutput = write;
+        let muted = false;
+        rl._writeToOutput = (s) => {
+            if (!muted)
+                process.stdout.write(s);
+        };
+        // An empty line (a paste that starts with a line break) does not end the reading: otherwise the
+        // rest of the paste falls into the shell prompt, visible (Lucas, 2026-09-28, the key leaked so).
+        rl.on("line", (line) => {
+            const value = line.trim();
+            if (!value)
+                return;
+            muted = false;
             rl.close();
             process.stdout.write("\n");
-            done(answer.trim());
+            done(value);
         });
+        process.stdout.write(question);
+        muted = true;
     });
 }
+const KEY_RE = /^sk-ant-[A-Za-z0-9_-]{20,200}$/;
+/**
+ * The key from the folder's .env (ANTHROPIC_API_KEY), shown only by its last 4 characters and used
+ * only with an s: no paste in the terminal at all.
+ */
+export async function keyFromEnvFile(folder, ask, log) {
+    const { vars } = await readEnvVars(folder).catch(() => ({ vars: [] }));
+    const found = vars.find((v) => v.key === "ANTHROPIC_API_KEY" && KEY_RE.test(v.value.trim()));
+    if (!found)
+        return null;
+    log(`Achei ANTHROPIC_API_KEY em ${found.file} (${maskValue(found.value.trim())}).`);
+    const answer = (await ask("Usar esta chave? [s/n] ")).trim().toLowerCase();
+    return answer === "s" || answer === "sim" ? found.value.trim() : null;
+}
 export function parseSetArgs(args) {
     const rest = [...args];
     const provider = rest.shift();
@@ -110,8 +148,13 @@ export async function runLlm(args, opts = {}) {
         if (!ctx)
             return 1;
         log(`Modelo ${parsed.model}, teto de US$ ${Number(parsed.cap).toFixed(2)} por dia. Cada pergunta passa a ser cobrada na sua conta da Anthropic.`);
-        const key = opts.ask ? await opts.ask("Chave da API da Anthropic (sk-ant-...): ") : await askHidden("Chave da API da Anthropic (sk-ant-..., não aparece na tela): ");
-        if (!/^sk-ant-[A-Za-z0-9_-]{20,200}$/.test(key)) {
+        const ask = opts.ask ?? askLine;
+        const fromFile = await keyFromEnvFile(resolve(parsed.folder), ask, log);
+        const key = fromFile ??
+            (opts.ask
+                ? await opts.ask("Chave da API da Anthropic (sk-ant-...): ")
+                : await askHidden("Cole a chave da API da Anthropic (sk-ant-...) e aperte Enter; ela não aparece na tela: "));
+        if (!KEY_RE.test(key)) {
             console.error("Isso não parece uma chave da API da Anthropic (sk-ant-...). Nada foi enviado.");
             return 1;
         }

package/dist/mcp.js

@@ -0,0 +1,289 @@
+import { appendFile, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { callApi } from "./api.js";
+import { loadToken, readSpaceConfig } from "./config.js";
+import { statusSpace } from "./status.js";
+import { terminalSafe } from "./ask.js";
+async function resolveContext(folder) {
+    const config = await readSpaceConfig(folder);
+    if (!config)
+        return { error: `${folder} não é um espaço Omni (falta .omni/space.json). Rode aqui dentro de uma pasta ligada com omnispace init.` };
+    if (!config.spaceId)
+        return { error: "Esta pasta foi vinculada pelo navegador, mas o espaço ainda não foi criado." };
+    const token = await loadToken(config.apiUrl);
+    if (!token)
+        return { error: `Nenhuma sessão da CLI nesta máquina para ${config.apiUrl}. Rode: omnispace login` };
+    return { apiUrl: config.apiUrl, token, spaceId: config.spaceId };
+}
+function text(value) {
+    return { content: [{ type: "text", text: value }] };
+}
+function apiError(res) {
+    const msg = terminalSafe(String(res.error ?? "falha desconhecida"));
+    if (res.expired || res.status === 401)
+        return `${msg} (rode omnispace login nesta máquina)`;
+    return msg;
+}
+/** `console.log` volta a ser `console.log` mesmo se `fn` lançar: nunca fica capturando por engano. */
+async function captureLog(fn) {
+    const original = console.log;
+    const lines = [];
+    console.log = (...args) => {
+        lines.push(args.map(String).join(" "));
+    };
+    try {
+        await fn();
+    }
+    finally {
+        console.log = original;
+    }
+    return lines.join("\n").trim();
+}
+export async function buildOmniMcpServer(folder) {
+    const server = new McpServer({ name: "omni", version: "1.0.0" });
+    server.registerTool("omni_status", {
+        title: "Status do espaço",
+        description: "A pasta e o servidor do Omni estão em dia? O que falta enviar ou trazer, em uma linha.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const summary = await captureLog(() => statusSpace(folder, { resumo: true }));
+        return text(summary || "Sem resumo.");
+    });
+    server.registerTool("omni_conectores", {
+        title: "Conectores do espaço",
+        description: "Conectores ligados neste espaço e o que cada ação pode fazer: automático, pede confirmação ou bloqueado.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const ctx = await resolveContext(folder);
+        if ("error" in ctx)
+            return text(ctx.error);
+        const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/permissions/list", { spaceId: ctx.spaceId });
+        if (!res.ok)
+            return text(apiError(res));
+        const rows = res.permissions ?? [];
+        if (rows.length === 0)
+            return text("Nenhum conector ligado neste espaço.");
+        const byConnector = new Map();
+        for (const r of rows) {
+            const list = byConnector.get(r.connectorId) ?? [];
+            list.push(`${r.actionKey} (${r.state})`);
+            byConnector.set(r.connectorId, list);
+        }
+        const lines = [...byConnector.entries()].map(([id, actions]) => `${id}: ${actions.join(", ")}`);
+        return text(lines.join("\n"));
+    });
+    server.registerTool("omni_ler", {
+        title: "Ler pelo conector",
+        description: "Roda uma ação de leitura (ou outra já automática neste espaço) de um conector, na hora. Uma ação em confirmar ou bloqueada é recusada; use omni_pedir para uma que pede confirmação.",
+        inputSchema: z.object({
+            conector: z.string().describe("id do conector, ex.: clickup, supabase, gohighlevel"),
+            acao: z.string().describe("chave da ação, ex.: list_tasks, query_table"),
+            entrada: z.record(z.string(), z.unknown()).optional().describe("parâmetros da ação"),
+        }),
+    }, async ({ conector, acao, entrada }) => {
+        const ctx = await resolveContext(folder);
+        if ("error" in ctx)
+            return text(ctx.error);
+        const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/actions/run", {
+            spaceId: ctx.spaceId,
+            connectorId: conector,
+            actionKey: acao,
+            input: entrada ?? {},
+        });
+        return text(res.ok ? String(res.output ?? "feito") : apiError(res));
+    });
+    server.registerTool("omni_pedir", {
+        title: "Pedir uma escrita",
+        description: "Registra um pedido pendente para uma ação de escrita (nunca executa). A pessoa confirma ou recusa depois no terminal, com omnispace confirmar. Não existe ferramenta pra confirmar por aqui.",
+        inputSchema: z.object({
+            conector: z.string().describe("id do conector, ex.: clickup, gohighlevel"),
+            acao: z.string().describe("chave da ação, ex.: create_task, create_contact"),
+            entrada: z.record(z.string(), z.unknown()).optional().describe("parâmetros da ação"),
+        }),
+    }, async ({ conector, acao, entrada }) => {
+        const ctx = await resolveContext(folder);
+        if ("error" in ctx)
+            return text(ctx.error);
+        const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/actions/request", {
+            spaceId: ctx.spaceId,
+            connectorId: conector,
+            actionKey: acao,
+            input: entrada ?? {},
+        });
+        if (!res.ok)
+            return text(apiError(res));
+        return text(`Pedido ${res.ref} registrado. Nada foi executado. Confirme ou recuse no terminal: omnispace confirmar ${res.ref}`);
+    });
+    server.registerTool("omni_uso", {
+        title: "Uso de modelo",
+        description: "Gasto de modelo da conta hoje e no mês, custo total.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const ctx = await resolveContext(folder);
+        if ("error" in ctx)
+            return text(ctx.error);
+        const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/usage", {});
+        if (!res.ok)
+            return text(apiError(res));
+        const today = res.today;
+        const month = res.thisMonth;
+        return text(`Hoje: ${today.calls} chamada(s), US$ ${today.costUsd.toFixed(4)}. No mês: ${month.calls} chamada(s), US$ ${month.costUsd.toFixed(4)}.`);
+    });
+    return server;
+}
+export async function runMcpServer(folder) {
+    const server = await buildOmniMcpServer(folder);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Omni MCP: servidor rodando por stdio.");
+    return new Promise(() => { }); // fica no ar até o processo pai (Claude Code) encerrar
+}
+// No Windows o `omni` global é um .cmd; clientes que abrem o processo sem shell (Claude Code nativo)
+// não o acham, então vai por `cmd /c`.
+export function omniServerEntry(platform = process.platform) {
+    return platform === "win32" ? { command: "cmd", args: ["/c", "omni", "mcp"] } : { command: "omni", args: ["mcp"] };
+}
+const MCP_TARGETS = [
+    { path: ".mcp.json", rootKey: "mcpServers", entry: omniServerEntry }, // Claude Code (terminal, extensão, app)
+    { path: ".cursor/mcp.json", rootKey: "mcpServers", entry: omniServerEntry }, // Cursor: não lê o .mcp.json
+    { path: ".vscode/mcp.json", rootKey: "servers", entry: () => ({ type: "stdio", ...omniServerEntry() }), onlyIfDir: ".vscode" },
+    { path: ".trae/mcp.json", rootKey: "mcpServers", entry: omniServerEntry, onlyIfDir: ".trae" },
+    // Zed chama MCP de "context servers" e lê o .zed/settings.json do projeto.
+    { path: ".zed/settings.json", rootKey: "context_servers", entry: () => ({ ...omniServerEntry(), env: {} }), onlyIfDir: ".zed" },
+    // Codex: TOML, `.codex/config.toml` do projeto (só vale em projeto confiável). O global fica manual.
+    { path: ".codex/config.toml", rootKey: "mcpServers", entry: omniServerEntry, onlyIfDir: ".codex", toml: true },
+];
+async function mergeServerInto(path, target) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch {
+        raw = undefined;
+    }
+    await mkdir(dirname(path), { recursive: true });
+    if (target.toml) {
+        // TOML sem parser: só acrescenta o bloco (append), nunca reescreve o que já existe.
+        if (raw !== undefined && /^\s*\[mcp_servers\.omni\]/m.test(raw))
+            return "updated";
+        const e = target.entry();
+        const block = `[mcp_servers.omni]\ncommand = ${JSON.stringify(e.command)}\nargs = ${JSON.stringify(e.args)}\n`;
+        const sep = raw === undefined || raw === "" ? "" : raw.endsWith("\n") ? "\n" : "\n\n";
+        await appendFile(path, `${sep}${block}`, "utf8");
+        return "added";
+    }
+    let existing = {};
+    if (raw !== undefined) {
+        try {
+            existing = JSON.parse(raw);
+        }
+        catch {
+            // Ilegível ou com comentários (comum no VS Code e no Zed): não mexe, para não perder as outras
+            // configurações da pessoa. O aviso diz o que colar.
+            return "skipped";
+        }
+    }
+    const servers = { ...(existing[target.rootKey] ?? {}) };
+    const had = Boolean(servers.omni);
+    servers.omni = target.entry();
+    const next = { ...existing, [target.rootKey]: servers };
+    const tmp = `${path}.${process.pid}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    await rename(tmp, path);
+    return had ? "updated" : "added";
+}
+async function isDir(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+// `.mcp.json` e `.cursor/mcp.json` sempre; os demais só se a pasta já é usada naquele editor.
+// `alreadyThere` é falso se algum arquivo ganhou o servidor agora; `skipped` são arquivos ilegíveis
+// (não tocados).
+export async function installMcpConfig(folder) {
+    const paths = [];
+    const skipped = [];
+    let alreadyThere = true;
+    for (const target of MCP_TARGETS) {
+        if (target.onlyIfDir && !(await isDir(join(folder, target.onlyIfDir))))
+            continue;
+        const path = join(folder, target.path);
+        const result = await mergeServerInto(path, target);
+        if (result === "skipped") {
+            skipped.push(path);
+            continue;
+        }
+        if (result === "added")
+            alreadyThere = false;
+        paths.push(path);
+    }
+    return { paths, alreadyThere, skipped };
+}
+// Rastros de cada editor: pasta própria no projeto ou variável que o próprio editor põe no terminal
+// integrado. Sem rastro nenhum, o texto lista todos.
+export async function detectEditors(folder, env = process.env) {
+    const found = [];
+    if ((await isDir(join(folder, ".cursor"))) || env.CURSOR_TRACE_ID)
+        found.push("cursor");
+    if ((await isDir(join(folder, ".claude"))) || env.CLAUDECODE)
+        found.push("claude-code");
+    if ((await isDir(join(folder, ".vscode"))) || (env.TERM_PROGRAM === "vscode" && !env.CURSOR_TRACE_ID))
+        found.push("vscode");
+    if (await isDir(join(folder, ".trae")))
+        found.push("trae");
+    if (await isDir(join(folder, ".zed")))
+        found.push("zed");
+    if ((await isDir(join(folder, ".codex"))) || env.CODEX_HOME || env.CODEX_SANDBOX)
+        found.push("codex");
+    return found;
+}
+const EDITOR_STEPS = {
+    cursor: "Cursor: Ctrl+Shift+P, \"Developer: Reload Window\"; depois Settings, Tools & MCP, e ligue o toggle do omni.",
+    "claude-code": "Claude Code: abra um chat novo na pasta e rode /mcp; aprove o servidor omni.",
+    vscode: "VS Code: Ctrl+Shift+P, \"MCP: List Servers\", e inicie o omni (confirme que confia nele).",
+    trae: "Trae: Settings, MCP, e ligue o MCP do projeto (Enable Project MCP); o omni aparece na lista.",
+    zed: "Zed: Settings, AI, MCP Servers; o omni aparece na lista (o ponto ao lado fica verde quando conecta).",
+    codex: "Codex: confie no projeto (só assim ele lê o .codex/config.toml) e rode /mcp; ou, para valer em todo projeto, `codex mcp add omni -- omni mcp`.",
+};
+export function mcpNextSteps(detected) {
+    if (detected.length === 0) {
+        return ["Não vi qual editor você usa. Onde ativar:", ...Object.values(EDITOR_STEPS).map((l) => `  ${l}`)].join("\n");
+    }
+    const names = detected.map((e) => EDITOR_STEPS[e].split(":")[0]).join(" e ");
+    return [`${detected.length > 1 ? "Detectados" : "Detectado"}: ${names}. Para ativar:`, ...detected.map((e) => `  ${EDITOR_STEPS[e]}`)].join("\n");
+}
+export function mcpSkippedNote(skipped) {
+    return [
+        "Não mexi nestes arquivos porque não consegui ler (comentários ou JSON quebrado), para não perder suas outras configurações:",
+        ...skipped.map((p) => `  ${p}`),
+        "Rode `omnispace mcp` para ver o comando e acrescente o servidor omni neles à mão.",
+    ].join("\n");
+}
+// Depois de sync, clone, vincular e init: liga o MCP nesta máquina sem a pessoa pedir. Os arquivos de
+// MCP levam o comando desta máquina (cmd /c no Windows) e por isso não sincronizam: cada máquina
+// se configura sozinha. Só fala quando algo foi criado; `OMNI_NO_MCP=1` desliga.
+export async function autoWireMcp(folder) {
+    if (process.env.OMNI_NO_MCP)
+        return;
+    try {
+        if (!(await isDir(join(folder, ".omni"))))
+            return;
+        const editors = await detectEditors(folder); // antes de instalar: o próprio install cria .cursor/
+        const { paths, alreadyThere, skipped } = await installMcpConfig(folder);
+        if (!alreadyThere) {
+            console.log(`\nMCP do Omni ligado nesta máquina (${paths.length} arquivo(s) de configuração).`);
+            console.log(mcpNextSteps(editors));
+        }
+        if (skipped.length)
+            console.log(`\n${mcpSkippedNote(skipped)}`);
+    }
+    catch {
+        // ligar o MCP nunca derruba o comando que a pessoa rodou
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnispace",
-  "version": "0.15.1",
+  "version": "0.17.0",
   "description": "Omni CLI (alpha): transforma uma pasta da sua máquina em um espaço Omni e sincroniza entre máquinas.",
   "type": "module",
   "bin": {
@@ -20,6 +20,10 @@
   "engines": {
     "node": ">=20"
   },
+  "dependencies": {
+    "@modelcontextprotocol/server": "^2.0.0",
+    "zod": "^4.6.5"
+  },
   "keywords": [
     "omni",
     "tzolkin",