omnispace 0.9.0 → 0.12.0

package/README.md

@@ -84,13 +84,31 @@ Tirar esta máquina da conta e o `.omni/` das pastas dela (pede duas confirmaç
 npx -y omnispace@latest desvincular
 ```
 
+Ver e mudar o que o agente pode fazer sozinho com cada ação dos conectores do espaço. Por padrão, leitura é automática, escrita pede confirmação e ação destrutiva fica bloqueada. Restringir vale na hora; liberar pede confirmação no navegador:
+
+```
+npx -y omnispace@latest permissoes
+npx -y omnispace@latest permissoes set slack send_message bloqueado
+```
+
 No Windows, se o caminho tiver espaço ou apóstrofo, entre na pasta com aspas duplas: `cd "C:\caminho\da\pasta"`.
 
 ## O que o Omni lê e envia
 
 - A pasta é lida para montar a lista de arquivos. Sobem só arquivos de texto (Markdown, código, JSON e afins), até 25 MB por arquivo e 100 MB por espaço. Nome de arquivo que o Windows não aceita (como `CON`, `a:b.md` ou terminado em ponto) fica de fora, para o espaço abrir em qualquer sistema.
-- Nunca sobem: `.env` e variações, chaves (`.pem`, `.key`, `id_rsa`), pastas `.git`, `node_modules` e de build, imagens e mídia, e o `.claude/settings.local.json` do Claude Code (configuração de cada máquina; o `.claude/settings.json` sincroniza).
-- Arquivos `.env` são lidos só para listar os nomes das chaves; nenhum valor é guardado ou enviado.
+- Nunca sobem: `.env` e variações, chaves (`.pem`, `.key`, `id_rsa`), pastas `.git`, `node_modules` e de build, imagens e mídia, e o `.claude/settings.local.json` do Claude Code (configuração de cada máquina; o `.claude/settings.json` sincroniza) e o `.claude/worktrees/` (cópias do repositório das sessões paralelas do Claude Code).
+- Arquivos `.env` são lidos só para listar os nomes das chaves; nenhum valor é guardado ou enviado. A exceção é `omnispace env push` (abaixo), quando você escolhe chave por chave.
 - Antes de enviar, a CLI mostra o que sobe e o que fica de fora e pede confirmação.
 - Na pasta, o Omni grava só `.omni/space.json` (e, só enquanto um sync roda, `.omni/lock`, `.omni/tmp/` e `.omni/pull-pending.json`, apagados no fim; `.omni/backups/` e `.omni/conflicts.json` quando há conflito). Se um sync for interrompido, rodar o mesmo comando de novo continua de onde parou. Nada disso sincroniza. O token de acesso fica em `~/.omni/credentials.json`, fora de qualquer projeto, legível só pelo seu usuário.
 - A CLI só fala com o servidor por HTTPS (`http` só vale para um servidor na própria máquina, em desenvolvimento).
+
+## Credenciais do `.env` no cofre do espaço
+
+```
+npx -y omnispace@latest env push
+```
+
+Com a CLI logada, dentro da pasta do espaço: a CLI lê os arquivos `.env` da raiz (menos `.env.example`, `.env.sample` e `.env.template`) e pergunta chave por chave se ela vai para o cofre do espaço. Mostra o nome, o arquivo e no máximo os 4 últimos caracteres do valor. Antes de enviar, pede que você confirme no navegador, logado na sua conta, digitando o código do terminal. O valor vai cifrado para o cofre (Vault) e não aparece em tela, log nem resposta. Sem terminal, nada é enviado.
+
+- `env list` mostra as chaves guardadas (só nomes).
+- `env rm <CHAVE> [--arquivo .env.local]` apaga do cofre de vez, também com confirmação no navegador. Se um conector usava a chave, ele fica desligado.

package/dist/ask.js

@@ -0,0 +1,115 @@
+import { basename, resolve } from "node:path";
+import { callApi } from "./api.js";
+import { loadToken, readSpaceConfig } from "./config.js";
+export const ASK_USAGE = 'Uso: omnispace ask "<pergunta>" [pasta] [--fontes] [--detalhes]';
+/** `ask "<pergunta>" [pasta] [--fontes] [--detalhes]`. The question must come quoted: one argument. */
+export function parseAskArgs(rest, cwd = process.cwd()) {
+    const positional = rest.filter((a) => !a.startsWith("--"));
+    const unknown = rest.filter((a) => a.startsWith("--") && a !== "--fontes" && a !== "--detalhes");
+    if (unknown.length > 0)
+        return { error: `Opção desconhecida: ${unknown[0]}\n${ASK_USAGE}` };
+    if (positional.length === 0 || !positional[0].trim())
+        return { error: ASK_USAGE };
+    if (positional.length > 2)
+        return { error: `Coloque a pergunta entre aspas.\n${ASK_USAGE}` };
+    return {
+        question: positional[0].trim(),
+        folder: resolve(cwd, positional[1] ?? "."),
+        sourcesOnly: rest.includes("--fontes"),
+        details: rest.includes("--detalhes"),
+    };
+}
+const REASON = { index: "index.md", log: "log.md", link: "apontado no index", termo: "busca por termo" };
+/** What `omnispace ask` prints, as lines. `baseVersion`: the version this folder is on. */
+export function formatAsk(res, opts) {
+    const out = [];
+    const consultedList = () => {
+        for (const c of res.consulted) {
+            out.push(`  [${c.id}] ${c.path}  (${REASON[c.reason] ?? c.reason}, ${c.chars.toLocaleString("pt-BR")} caracteres${c.truncated ? ", em parte" : ""})`);
+        }
+    };
+    if (opts.sourcesOnly) {
+        out.push(`Arquivos que entrariam na resposta (versão ${res.version}, sem chamar o modelo):`);
+        if (res.consulted.length === 0)
+            out.push("  nenhum");
+        consultedList();
+    }
+    else {
+        out.push("Resposta:", res.answer ?? "", "");
+        const sources = res.sources ?? [];
+        if (sources.length > 0) {
+            out.push("Fontes:");
+            for (const s of sources)
+                out.push(`  [${s.id}] ${s.path}  (versão ${s.version})`);
+        }
+        else {
+            out.push("Fontes: nenhuma citada. Esta resposta não se apoia em arquivo do espaço.");
+        }
+    }
+    out.push("", "Limites:");
+    for (const limit of res.limits)
+        out.push(`  - ${limit}`);
+    if (res.version > 0 && opts.baseVersion < res.version) {
+        out.push(`  - Esta pasta está na versão ${opts.baseVersion}; a resposta usa a versão ${res.version} do servidor.`);
+    }
+    if (opts.details) {
+        const s = res.stats;
+        if (!opts.sourcesOnly) {
+            out.push("", "Consultados:");
+            consultedList();
+        }
+        out.push("", "Custo desta pergunta:");
+        out.push(`  arquivos: ${s.filesUsed ?? 0} usados, ${s.filesScanned ?? 0} lidos na busca, ${s.filesInVersion ?? 0} na versão`);
+        out.push(`  contexto: ${(s.contextChars ?? 0).toLocaleString("pt-BR")} caracteres`);
+        if (s.model) {
+            out.push(`  modelo: ${s.model}, ${s.inputTokens ?? 0} tokens de entrada, ${s.outputTokens ?? 0} de saída`);
+            out.push(`  custo estimado: US$ ${(s.costUsd ?? 0).toFixed(5)}`);
+        }
+        if (s.ms !== undefined)
+            out.push(`  tempo: ${(s.ms / 1000).toFixed(1)} s`);
+    }
+    return out;
+}
+/**
+ * `omnispace ask`: a question about this folder's space, answered by the server from the latest
+ * published version. Reads nothing from the folder besides .omni/space.json, and writes nothing.
+ * Never retried: an answer costs tokens.
+ */
+export async function askSpace(args) {
+    const config = await readSpaceConfig(args.folder);
+    if (!config) {
+        console.log(`\n${basename(args.folder)} não é um espaço Omni (não tem .omni/space.json).`);
+        console.log("Rode o ask de dentro da pasta de um espaço, ou passe o caminho dela.\n");
+        return 1;
+    }
+    if (!config.spaceId) {
+        console.log("\nEsta pasta foi vinculada pelo navegador, mas o espaço ainda não foi criado.\n");
+        return 1;
+    }
+    const token = await loadToken(config.apiUrl);
+    if (!token) {
+        console.log(`\nNenhuma sessão da CLI nesta máquina para ${config.apiUrl}.`);
+        console.log("Para entrar: omnispace login\n");
+        return 1;
+    }
+    if (!args.sourcesOnly)
+        console.log("\n→ Consultando a versão publicada...");
+    const res = await callApi(config.apiUrl, token, "/api/cli/ask", {
+        spaceId: config.spaceId,
+        question: args.question,
+        sourcesOnly: args.sourcesOnly,
+    });
+    if (!res.ok) {
+        console.log(`\nSem resposta: ${res.error}`);
+        if (res.expired || res.status === 401)
+            console.log("Para entrar de novo: omnispace login");
+        console.log("");
+        return 1;
+    }
+    console.log("");
+    const opts = { baseVersion: config.baseVersion, sourcesOnly: args.sourcesOnly, details: args.details };
+    for (const line of formatAsk(res, opts))
+        console.log(line);
+    console.log("");
+    return 0;
+}

package/dist/dotenv.js

@@ -0,0 +1,100 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+// Leitura dos `.env` da pasta para `omnispace env push` (pós-marco C1; ADR 004). Diferente da
+// varredura (scan.ts), aqui o valor é lido de propósito, porque a pessoa vai decidir chave por chave
+// o que sobe para o cofre. O valor fica só na memória deste processo: nunca é impresso (só os 4
+// últimos caracteres, e só de valor longo), nunca vai para arquivo nem para log.
+const MAX_ENV_BYTES = 256 * 1024;
+/** Same rule as the server (lib/cli-verify.ts): `.env`, `.env.local`, `.env.production.local`. */
+export const ENV_FILE_RE = /^\.env(\.[A-Za-z0-9_-]{1,32}){0,3}$/;
+const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+/** Files that hold placeholders, not the real values. */
+const TEMPLATE_RE = /(^|\.)(example|sample|template|dist|defaults?)(\.|$)/i;
+/**
+ * Parses a `.env` the way dotenv does for the common cases: `export KEY=v`, spaces around `=`,
+ * unquoted values with a trailing ` # comment`, single quotes (literal), double quotes (with \n and
+ * multi-line). A later line with the same key wins. Lines that are not assignments are skipped.
+ */
+export function parseDotenv(text, file = ".env") {
+    const lines = text.replace(/^/, "").split(/\r?\n/);
+    const byKey = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const eq = line.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = line.slice(0, eq).replace(/^export\s+/, "").trim();
+        if (!ENV_KEY_RE.test(key))
+            continue;
+        let rest = line.slice(eq + 1).trim();
+        let value;
+        const quote = rest[0];
+        if (quote === '"' || quote === "'" || quote === "`") {
+            // Multi-line quoted value: keep reading lines until the closing quote.
+            let body = rest.slice(1);
+            let close = findClosing(body, quote);
+            while (close < 0 && i + 1 < lines.length) {
+                i++;
+                body += `\n${lines[i]}`;
+                close = findClosing(body, quote);
+            }
+            if (close < 0)
+                continue; // never closed: not a value we can trust
+            value = body.slice(0, close);
+            if (quote === '"')
+                value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+        }
+        else {
+            const hash = rest.search(/\s#/);
+            if (hash >= 0)
+                rest = rest.slice(0, hash);
+            value = rest.trim();
+        }
+        byKey.set(key, { file, key, value });
+    }
+    return [...byKey.values()];
+}
+function findClosing(body, quote) {
+    for (let i = 0; i < body.length; i++) {
+        if (body[i] === "\\" && quote === '"') {
+            i++;
+            continue;
+        }
+        if (body[i] === quote)
+            return i;
+    }
+    return -1;
+}
+/** The `.env` files at the root of the folder, without templates, in a stable order. */
+export async function listEnvFiles(root) {
+    const entries = await readdir(root, { withFileTypes: true });
+    return entries
+        .filter((e) => e.isFile() && ENV_FILE_RE.test(e.name) && !TEMPLATE_RE.test(e.name.slice(4)))
+        .map((e) => e.name)
+        .sort((a, b) => (a === ".env" ? -1 : b === ".env" ? 1 : a.localeCompare(b)));
+}
+/** Every variable of every `.env` at the root. Empty values are skipped (nothing to keep). */
+export async function readEnvVars(root) {
+    const vars = [];
+    const skipped = [];
+    for (const file of await listEnvFiles(root)) {
+        const path = join(root, file);
+        if ((await stat(path)).size > MAX_ENV_BYTES) {
+            skipped.push(file);
+            continue;
+        }
+        vars.push(...parseDotenv(await readFile(path, "utf8"), file).filter((v) => v.value !== ""));
+    }
+    return { vars, skipped };
+}
+/**
+ * What the terminal shows of a value: the last 4 characters, and only when the value is long enough
+ * for 4 characters to say nothing useful about it (ADR 004 and barrier 4).
+ */
+export function maskValue(value) {
+    if (value.length < 12 || /\s/.test(value.slice(-4)))
+        return "(valor não mostrado)";
+    return `••••${value.slice(-4)}`;
+}

package/dist/env.js

@@ -0,0 +1,243 @@
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { callApi } from "./api.js";
+import { insecureApiUrl, loadToken, readSpaceConfig } from "./config.js";
+import { maskValue, readEnvVars } from "./dotenv.js";
+import { openBrowser } from "./login.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+const STATUS_TEXT = {
+    active: "conectado",
+    active_limited: "conectado com limitação",
+    error: "com erro",
+    disabled: "desligado",
+};
+const USAGE = `Uso:
+  omnispace env push [pasta]                      pergunta chave por chave o que vai para o cofre do espaço
+  omnispace env list [pasta]                      mostra as chaves guardadas (só nomes)
+  omnispace env rm <CHAVE>... [--arquivo .env] [--pasta <pasta>]  apaga do cofre, de vez`;
+async function askTerminal(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/** The space of this folder and this machine's session, or a printed reason why not. */
+export async function context(root) {
+    const config = await readSpaceConfig(root);
+    if (!config?.spaceId) {
+        console.error(config ? "O espaço desta pasta ainda não foi criado. Termine a conta no navegador." : "Esta pasta não é um espaço Omni. Rode omnispace init primeiro.");
+        return null;
+    }
+    // Barrier 1: credentials only travel over https, whatever the folder's config says.
+    const insecure = insecureApiUrl(config.apiUrl);
+    if (insecure) {
+        console.error(insecure);
+        return null;
+    }
+    const token = await loadToken(config.apiUrl);
+    if (!token) {
+        console.error("Nenhuma sessão da CLI nesta máquina. Para entrar: omnispace login");
+        return null;
+    }
+    return { apiUrl: config.apiUrl, token, spaceId: config.spaceId };
+}
+export function refused(res, what) {
+    console.error(`${what}: ${res.error}`);
+    if (res.expired || res.status === 401)
+        console.error("Para entrar de novo: omnispace login");
+}
+/**
+ * Asks for the on-the-spot verification and waits for the browser. Returns the device code to send
+ * with the action, or null (refused, expired, failed).
+ */
+export async function verify(ctx, action, keys, opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const start = await callApi(ctx.apiUrl, ctx.token, "/api/cli/verify/start", { spaceId: ctx.spaceId, action, keys }, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!start.ok) {
+        refused(start, "Falha ao pedir a verificação");
+        return null;
+    }
+    const deviceCode = start.deviceCode;
+    const expiresAt = Date.now() + start.expiresIn * 1000;
+    const waitMs = opts.pollMs ?? start.interval * 1000;
+    log("");
+    log("Confirme no navegador, logado na sua conta:");
+    log(`  ${start.verifyUrl}`);
+    log("e digite este código:");
+    log(`  ${start.userCode}`);
+    log("");
+    if (opts.openBrowser)
+        openBrowser(start.verifyUrl);
+    log("→ Esperando a confirmação (Ctrl+C cancela, nada é enviado)...");
+    while (Date.now() < expiresAt) {
+        await new Promise((r) => setTimeout(r, waitMs));
+        const poll = await callApi(ctx.apiUrl, ctx.token, "/api/cli/verify/poll", { deviceCode }, { retryDelaysMs: RETRY_DELAYS_MS });
+        if (poll.ok && poll.state === "pending")
+            continue;
+        if (poll.ok && poll.state === "approved")
+            return deviceCode;
+        console.error(poll.denied ? "Recusado no navegador. Nada foi enviado." : `Verificação não concluída: ${poll.error}`);
+        return null;
+    }
+    console.error("O código expirou antes da confirmação. Nada foi enviado.");
+    return null;
+}
+async function readVault(ctx) {
+    const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/env/list", { spaceId: ctx.spaceId }, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!res.ok) {
+        refused(res, "Falha ao ler o cofre do espaço");
+        return null;
+    }
+    return { keys: res.keys, connectors: (res.connectors ?? []) };
+}
+async function push(root, opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const ask = opts.ask ?? askTerminal;
+    const interactive = opts.interactive ?? Boolean(process.stdin.isTTY);
+    if (!interactive) {
+        console.error("omnispace env push só roda num terminal, porque cada chave é decidida por você. Nada foi enviado.");
+        return 1;
+    }
+    const ctx = await context(root);
+    if (!ctx)
+        return 1;
+    const { vars, skipped } = await readEnvVars(root);
+    for (const file of skipped)
+        console.error(`${file} ficou de fora: maior que 256 KB.`);
+    if (vars.length === 0) {
+        log("Nenhuma variável com valor nos arquivos .env da raiz desta pasta. Nada a enviar.");
+        return 0;
+    }
+    const vault = await readVault(ctx);
+    if (!vault)
+        return 1;
+    const already = new Set(vault.keys.map((s) => `${s.file}\n${s.key}`));
+    log("");
+    log(`${vars.length} variáveis nos arquivos .env desta pasta. Para cada uma, responda:`);
+    log("  s = guardar no cofre do espaço   n = pular   q = parar de perguntar");
+    log("O valor vai cifrado para o cofre (Vault) e nunca aparece na tela nem em log.");
+    log("");
+    const accepted = [];
+    for (const v of vars) {
+        const note = already.has(`${v.file}\n${v.key}`) ? "  [já está no cofre, será substituída]" : "";
+        const answer = (await ask(`  ${v.key}  (${v.file})  ${maskValue(v.value)}${note}  Guardar? [s/n/q] `)).toLowerCase();
+        if (answer === "q")
+            break;
+        if (answer === "s" || answer === "sim" || answer === "y")
+            accepted.push(v);
+    }
+    if (accepted.length === 0) {
+        log("\nNada escolhido. Nada foi enviado.");
+        return 0;
+    }
+    const keys = accepted.map(({ file, key }) => ({ file, key }));
+    const deviceCode = await verify(ctx, "env_push", keys, opts);
+    if (!deviceCode)
+        return 1;
+    const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/env/store", {
+        spaceId: ctx.spaceId,
+        verification: deviceCode,
+        entries: accepted.map(({ file, key, value }) => ({ file, key, value })),
+    });
+    if (!res.ok) {
+        refused(res, "O cofre recusou o envio");
+        return 1;
+    }
+    log("");
+    for (const s of res.stored) {
+        log(`✓ ${s.key} (${s.file}) ${s.replaced ? "substituída" : "guardada"} no cofre`);
+    }
+    for (const c of (res.connectors ?? [])) {
+        log(`${c.state === "linked" ? "✓" : "!"} ${c.message}`);
+        if (c.test?.ok)
+            log("  ✓ Teste de conexão passou: o conector está ligado para o Omni neste espaço.");
+        else if (c.test)
+            log(`  ✗ Teste de conexão falhou: ${c.test.message ?? "sem detalhe"}. O conector fica desligado até passar.`);
+    }
+    log("");
+    return 0;
+}
+async function list(root, opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const ctx = await context(root);
+    if (!ctx)
+        return 1;
+    const vault = await readVault(ctx);
+    if (!vault)
+        return 1;
+    if (vault.keys.length === 0) {
+        log("O cofre deste espaço está vazio. Para guardar chaves do .env: omnispace env push");
+    }
+    else {
+        log(`${vault.keys.length} chave(s) no cofre deste espaço (só nomes, nenhum valor sai do cofre):`);
+        for (const s of vault.keys)
+            log(`  ${s.key}  (${s.file})  atualizada em ${new Date(s.updatedAt).toLocaleString("pt-BR")}`);
+    }
+    if (vault.connectors.length > 0) {
+        log("");
+        log("Conectores do espaço:");
+        for (const c of vault.connectors) {
+            const state = !c.hasCredential ? "sem credencial" : (STATUS_TEXT[c.status] ?? c.status);
+            log(`  ${c.name}: ${state}${c.status === "error" && c.message ? ` (${c.message})` : ""}`);
+        }
+    }
+    return 0;
+}
+async function remove(root, names, file, opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    if (names.length === 0) {
+        console.error(USAGE);
+        return 1;
+    }
+    const ctx = await context(root);
+    if (!ctx)
+        return 1;
+    const vault = await readVault(ctx);
+    if (!vault)
+        return 1;
+    const targets = vault.keys.filter((s) => names.includes(s.key) && (!file || s.file === file)).map(({ file: f, key }) => ({ file: f, key }));
+    const unknown = names.filter((n) => !targets.some((t) => t.key === n));
+    for (const n of unknown)
+        console.error(`${n}${file ? ` (${file})` : ""} não está no cofre deste espaço.`);
+    if (targets.length === 0)
+        return 1;
+    log(`Vai apagar do cofre, de vez: ${targets.map((t) => `${t.key} (${t.file})`).join(", ")}`);
+    const deviceCode = await verify(ctx, "env_rm", targets, opts);
+    if (!deviceCode)
+        return 1;
+    const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/env/remove", { spaceId: ctx.spaceId, verification: deviceCode, keys: targets });
+    if (!res.ok) {
+        refused(res, "O cofre recusou");
+        return 1;
+    }
+    for (const r of res.removed)
+        log(`✓ ${r.key} (${r.file}) apagada do cofre`);
+    for (const c of (res.disconnected ?? []))
+        log(`! O conector ${c} usava essa credencial: a cópia dele foi apagada e ele ficou desligado.`);
+    return unknown.length > 0 ? 1 : 0;
+}
+/** `omnispace env <push|list|rm> ...`, the one entry in the dispatcher (index.ts). */
+export async function runEnv(args, opts = {}) {
+    const [sub, ...rest] = args;
+    const valueOf = (flag) => {
+        const eq = rest.find((a) => a.startsWith(`${flag}=`));
+        if (eq)
+            return eq.slice(flag.length + 1);
+        const i = rest.indexOf(flag);
+        return i >= 0 ? rest[i + 1] : undefined;
+    };
+    // The word after `--arquivo` or `--pasta` is that flag's value, not a key name.
+    const flagValues = new Set(["--arquivo", "--pasta"].map((f) => rest.indexOf(f)).filter((i) => i >= 0).map((i) => rest[i + 1]));
+    const positional = rest.filter((a) => !a.startsWith("-") && !flagValues.has(a));
+    if (sub === "push")
+        return push(resolve(positional[0] ?? process.cwd()), opts);
+    if (sub === "list")
+        return list(resolve(positional[0] ?? process.cwd()), opts);
+    if (sub === "rm")
+        return remove(resolve(valueOf("--pasta") ?? process.cwd()), positional, valueOf("--arquivo"), opts);
+    console.error(USAGE);
+    return 1;
+}

package/dist/include.js

@@ -9,6 +9,15 @@ export const SKIP_DIRS = new Set([
     "node_modules", ".git", ".next", ".vercel", "dist", "build", "out", "coverage",
     ".turbo", ".cache", "venv", ".venv", "__pycache__", ".idea", ".vscode", "target",
 ]);
+/**
+ * Folders skipped by where they are, not by their name alone. `.claude/worktrees/` holds full copies
+ * of a repo that Claude Code sessions work on in parallel (Lucas, 2026-09-28): synced, every copy
+ * would go up as text. Matches at any depth (a repo inside the space can have its own).
+ */
+const SKIP_DIR_PATHS_RE = /(^|\/)\.claude\/worktrees$/i;
+export function isSkippedDirPath(path) {
+    return SKIP_DIR_PATHS_RE.test(path);
+}
 // Local state of the Omni link itself: machine specific, never part of the space. `.omni/tmp/`
 // holds downloads of an unfinished pull (fatia 3); `.omni/conflicts.json` and `.omni/backups/`
 // are the conflict resolution of this machine (fatia 4); `.omni/pull-pending.json` and
@@ -74,7 +83,8 @@ export function isMachineConfig(path) {
  */
 export function neverSyncs(path) {
     const name = path.slice(path.lastIndexOf("/") + 1);
-    return isSecret(name) || isMachineConfig(path) || isLocalOnly(path);
+    const inSkippedDir = /(^|\/)\.claude\/worktrees\//i.test(path);
+    return isSecret(name) || isMachineConfig(path) || isLocalOnly(path) || inSkippedDir;
 }
 export function isText(name) {
     const lower = name.toLowerCase();
@@ -143,7 +153,7 @@ export async function buildManifest(root) {
             const abs = join(dir, entry.name);
             const relParts = [...parts, entry.name];
             if (entry.isDirectory()) {
-                if (SKIP_DIRS.has(entry.name))
+                if (SKIP_DIRS.has(entry.name) || isSkippedDirPath(normalizePath(relParts)))
                     continue;
                 // A subfolder with its own .git (repo, submodule or worktree) DOES sync, text only: the
                 // agent needs the code to act on it (find a bug, fix it, report back). Lucas, 2026-09-23,

package/dist/index.js

@@ -16,6 +16,9 @@ import { initWithAccount } from "./init-account.js";
 import { statusSpace } from "./status.js";
 import { terminalAsk, unlinkMachine } from "./desvincular.js";
 import { linkExistingSpace } from "./vincular.js";
+import { askSpace, parseAskArgs } from "./ask.js";
+import { runEnv } from "./env.js";
+import { runPermissoes } from "./permissoes.js";
 const USAGE = `
 Omni CLI
 
@@ -27,12 +30,17 @@ Uso:
   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
 
 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.
@@ -59,6 +67,10 @@ async function main(argv) {
         return runSync(args.slice(1));
     if (command === "clone")
         return runClone(args.slice(1));
+    if (command === "env")
+        return runEnv(args.slice(1), { openBrowser: process.stdout.isTTY });
+    if (command === "permissoes")
+        return runPermissoes(args.slice(1), { openBrowser: process.stdout.isTTY });
     if (command === "vincular") {
         const rest = args.slice(1);
         const espacoIndex = rest.indexOf("--espaco");
@@ -72,6 +84,14 @@ async function main(argv) {
         const rest = args.slice(1);
         return statusSpace(resolve(rest.find((a) => !a.startsWith("-")) ?? process.cwd()), { resumo: rest.includes("--resumo") });
     }
+    if (command === "ask") {
+        const ask = parseAskArgs(args.slice(1));
+        if ("error" in ask) {
+            console.error(ask.error);
+            return 1;
+        }
+        return askSpace(ask);
+    }
     if (command !== "init") {
         console.error(`Comando desconhecido: ${command}`);
         console.log(USAGE.trim());

package/dist/login.js

@@ -10,7 +10,7 @@ import { RETRY_DELAYS_MS } from "./retry.js";
  * Opens the page in the default browser. Best effort: the URL is always printed too. Only http(s)
  * URLs, and never through a shell (on Windows `cmd /c start` would parse `&` and `|` in the URL).
  */
-function openBrowser(url) {
+export function openBrowser(url) {
     if (!/^https?:\/\//.test(url))
         return;
     const os = platform();

package/dist/permissoes.js

@@ -0,0 +1,92 @@
+import { resolve } from "node:path";
+import { callApi } from "./api.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+import { context, refused, verify } from "./env.js";
+// `omnispace permissoes` (docs/plan/permissoes-por-acao.md; Lucas, 2026-09-28): what the agent may
+// do on its own with each connector action of the space. Tightening applies right away; loosening
+// asks for the confirmation in the browser, like a credential.
+const STATES = ["automatico", "confirmar", "bloqueado"];
+const STATE_LABEL = { automatico: "automático", confirmar: "pedir confirmação", bloqueado: "bloqueado" };
+const ORIGIN_LABEL = { padrao: "padrão do Omni", usuario: "definida por você", importacao: "importada" };
+const USAGE = `Uso:
+  omnispace permissoes [pasta]                                  lista as ações dos conectores do espaço e o que o agente pode fazer
+  omnispace permissoes set <conector> <ação> <estado> [pasta]   muda uma ação: automatico, confirmar ou bloqueado
+Liberar (bloqueado para confirmar, ou para automático) pede confirmação no navegador; restringir vale na hora.`;
+export function parseStateArg(value) {
+    const plain = (value ?? "").toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "");
+    return STATES.find((s) => s === plain) ?? null;
+}
+async function list(root, opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const ctx = await context(root);
+    if (!ctx)
+        return 1;
+    const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/permissions/list", { spaceId: ctx.spaceId }, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!res.ok) {
+        refused(res, "Falha ao ler as permissões");
+        return 1;
+    }
+    const rows = res.permissions;
+    if (rows.length === 0) {
+        log("Este espaço ainda não tem conector. As permissões aparecem aqui quando houver um (omnispace env push).");
+        return 0;
+    }
+    let current = "";
+    for (const r of rows) {
+        if (r.connectorId !== current) {
+            current = r.connectorId;
+            log(`\n${r.connectorName} (${r.connectorId})`);
+        }
+        log(`  ${r.actionKey.padEnd(22)} ${r.actionName.padEnd(26)} ${r.kind.padEnd(10)} ${STATE_LABEL[r.state].padEnd(18)} ${ORIGIN_LABEL[r.origin] ?? r.origin}`);
+    }
+    log("\nPara mudar: omnispace permissoes set <conector> <ação> <automatico|confirmar|bloqueado>");
+    return 0;
+}
+async function set(root, connectorId, actionKey, state, opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const ctx = await context(root);
+    if (!ctx)
+        return 1;
+    const changes = [{ connectorId, actionKey, state }];
+    // Not retried: a repeat after a cut connection is harmless (same state), but it is reported.
+    let res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/permissions/set", { spaceId: ctx.spaceId, changes });
+    if (!res.ok && res.needsVerification) {
+        log(`Liberar ${connectorId}:${actionKey} (${STATE_LABEL[state]}) deixa o agente fazer mais sozinho.`);
+        const interactive = opts.interactive ?? Boolean(process.stdin.isTTY);
+        if (!interactive) {
+            console.error("Sem terminal para acompanhar a confirmação no navegador. Nada mudou.");
+            return 1;
+        }
+        const code = await verify(ctx, "perm_set", [{ file: `${connectorId}:${actionKey}`, key: state }], opts);
+        if (!code)
+            return 1;
+        res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/permissions/set", { spaceId: ctx.spaceId, changes, verification: code });
+    }
+    if (!res.ok) {
+        refused(res, "A permissão não mudou");
+        return 1;
+    }
+    const applied = res.applied;
+    if (applied.length === 0)
+        log(`${connectorId}:${actionKey} já estava como ${STATE_LABEL[state]}. Nada mudou.`);
+    else
+        log(`✓ ${connectorId}:${actionKey}: ${STATE_LABEL[applied[0].from]} → ${STATE_LABEL[applied[0].to]}.`);
+    return 0;
+}
+export async function runPermissoes(args, opts = {}) {
+    const [first, ...rest] = args;
+    if (first === "set") {
+        const [connectorId, actionKey, stateArg, folder] = rest;
+        const state = parseStateArg(stateArg);
+        if (!connectorId || !actionKey || !state) {
+            console.error(USAGE);
+            return 1;
+        }
+        return set(resolve(folder ?? process.cwd()), connectorId, actionKey, state, opts);
+    }
+    if (first === "--help" || first === "-h" || first === "help") {
+        console.log(USAGE);
+        return 0;
+    }
+    return list(resolve(first && first !== "list" ? first : (rest[0] ?? process.cwd())), opts);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnispace",
-  "version": "0.9.0",
+  "version": "0.12.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": {