omnispace 0.14.0 → 0.15.1

package/dist/ask.js

@@ -102,6 +102,9 @@ export function formatAsk(res, opts) {
         }
         if (s.ms !== undefined)
             out.push(`  tempo: ${(s.ms / 1000).toFixed(1)} s`);
+        if (s.steps?.length) {
+            out.push(`  passos do modelo: ${s.steps.map((st, i) => `${i + 1}) ${st.finish}, ${st.toolCalls} ferramenta(s), ${st.textChars} caracteres de texto`).join("; ")}`);
+        }
     }
     return out;
 }
@@ -167,11 +170,25 @@ export async function askSpace(args, opts = {}) {
     }
     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,
-    });
+    const body = { spaceId: config.spaceId, question: args.question, sourcesOnly: args.sourcesOnly };
+    let res = await callApi(config.apiUrl, token, "/api/cli/ask", body);
+    // The person's own LLM key failed (docs/plan/byok-e-medicao.md, decision 1): the Omni's model
+    // answers only if they say yes now. Without a terminal, nothing else is tried.
+    if (!res.ok && res.byokFailed === true) {
+        console.log(`\n${terminalSafe(String(res.error))}`);
+        const interactive = opts.interactive ?? Boolean(process.stdin.isTTY);
+        if (!interactive) {
+            console.log("Sem terminal para perguntar; nada foi respondido. Rode de novo com um terminal para usar o modelo do Omni.\n");
+            return 1;
+        }
+        const answer = (await (opts.ask ?? askTerminal)("Responder com o modelo gratuito do Omni desta vez? [s/n] ")).toLowerCase();
+        if (answer !== "s" && answer !== "sim") {
+            console.log("Nada foi respondido.\n");
+            return 1;
+        }
+        console.log("\n→ Consultando com o modelo do Omni...");
+        res = await callApi(config.apiUrl, token, "/api/cli/ask", { ...body, engine: "omni" });
+    }
     if (!res.ok) {
         console.log(`\nSem resposta: ${res.error}`);
         if (res.expired || res.status === 401)

package/dist/index.js

@@ -19,6 +19,8 @@ import { linkExistingSpace } from "./vincular.js";
 import { askSpace, parseAskArgs } from "./ask.js";
 import { runEnv } from "./env.js";
 import { runPermissoes } from "./permissoes.js";
+import { runUso } from "./uso.js";
+import { runLlm } from "./llm.js";
 const USAGE = `
 Omni CLI
 
@@ -41,6 +43,8 @@ Uso:
   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.
@@ -71,6 +75,10 @@ async function main(argv) {
         return runEnv(args.slice(1), { openBrowser: process.stdout.isTTY });
     if (command === "permissoes")
         return runPermissoes(args.slice(1), { openBrowser: process.stdout.isTTY });
+    if (command === "uso")
+        return runUso(args.slice(1));
+    if (command === "llm")
+        return runLlm(args.slice(1), { openBrowser: process.stdout.isTTY });
     if (command === "vincular") {
         const rest = args.slice(1);
         const espacoIndex = rest.indexOf("--espaco");

package/dist/llm.js

@@ -0,0 +1,150 @@
+import { resolve } from "node:path";
+import { createInterface } from "node:readline";
+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";
+// `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
+// shell history), goes to the Vault once the browser approves, and is never shown again.
+const MODELS = { haiku: "claude-haiku-4-5", sonnet: "claude-sonnet-5-5" };
+export const LLM_USAGE = `Uso:
+  omnispace llm                                       qual modelo responde as suas perguntas, teto e gasto de hoje
+  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.`;
+export function formatLlmStatus(s) {
+    if (!s.provider) {
+        return [
+            "As suas perguntas rodam no modelo gratuito do Omni (gpt-oss:20b), dentro da cota diária do seu plano.",
+            "Para usar a sua chave da Anthropic: omnispace llm set anthropic",
+        ];
+    }
+    const out = [
+        `Chave: ${s.provider}, terminando em ${s.keyLast4}, modelo ${s.model}${s.enabled ? "" : " (desligada)"}`,
+        `Teto: US$ ${(s.dailyCapUsd ?? 0).toFixed(2)} por dia; gasto hoje: US$ ${(s.spentTodayUsd ?? 0).toFixed(6)}`,
+    ];
+    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. */
+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;
+            rl.close();
+            process.stdout.write("\n");
+            done(answer.trim());
+        });
+    });
+}
+export function parseSetArgs(args) {
+    const rest = [...args];
+    const provider = rest.shift();
+    if (provider !== "anthropic")
+        return { error: "Por enquanto só a Anthropic: omnispace llm set anthropic" };
+    let model = MODELS.haiku;
+    let cap = "2";
+    let folder = ".";
+    while (rest.length > 0) {
+        const a = rest.shift();
+        if (a === "--modelo") {
+            const m = MODELS[(rest.shift() ?? "").toLowerCase()];
+            if (!m)
+                return { error: "Modelo: haiku ou sonnet." };
+            model = m;
+        }
+        else if (a === "--teto") {
+            const v = (rest.shift() ?? "").replace(",", ".");
+            if (!/^\d{1,4}(\.\d{1,2})?$/.test(v) || Number(v) <= 0 || Number(v) > 1000)
+                return { error: "Teto: um valor em US$ por dia, de 0.01 a 1000." };
+            cap = String(Number(v));
+        }
+        else if (a.startsWith("--")) {
+            return { error: `Opção desconhecida: ${a}` };
+        }
+        else {
+            folder = a;
+        }
+    }
+    return { provider, model, cap, folder };
+}
+export async function runLlm(args, opts = {}) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const sub = args[0];
+    if (!sub || sub === "status") {
+        const apiUrl = defaultApiUrl();
+        const token = await loadToken(apiUrl);
+        if (!token) {
+            console.error("Nenhuma sessão da CLI nesta máquina. Para entrar: omnispace login");
+            return 1;
+        }
+        const res = await callApi(apiUrl, token, "/api/cli/llm/status", {}, { retryDelaysMs: RETRY_DELAYS_MS });
+        if (!res.ok) {
+            refused(res, "Falha ao ler a chave de LLM");
+            return 1;
+        }
+        for (const line of formatLlmStatus(res))
+            log(line);
+        return 0;
+    }
+    if (sub === "set") {
+        const parsed = parseSetArgs(args.slice(1));
+        if ("error" in parsed) {
+            console.error(`${parsed.error}\n\n${LLM_USAGE}`);
+            return 1;
+        }
+        const interactive = opts.interactive ?? Boolean(process.stdin.isTTY);
+        if (!interactive) {
+            console.error("A chave é pedida escondida no terminal; rode num terminal.");
+            return 1;
+        }
+        const ctx = await context(resolve(parsed.folder));
+        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)) {
+            console.error("Isso não parece uma chave da API da Anthropic (sk-ant-...). Nada foi enviado.");
+            return 1;
+        }
+        const refs = [{ file: "llm:anthropic", key: `${parsed.model}|${parsed.cap}` }];
+        const verification = await verify(ctx, "llm_set", refs, opts);
+        if (!verification)
+            return 1;
+        // Not retried: it carries the key, and a failure is better said than repeated.
+        const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/llm/set", { spaceId: ctx.spaceId, verification, keys: refs, key });
+        if (!res.ok) {
+            refused(res, "A chave não foi ligada");
+            return 1;
+        }
+        log(`✓ Chave terminando em ${String(res.keyLast4)} ligada. As suas perguntas rodam agora em ${String(res.model)}, até US$ ${Number(res.dailyCapUsd).toFixed(2)} por dia.`);
+        log("  Para ver o gasto: omnispace uso   Para desligar: omnispace llm rm");
+        return 0;
+    }
+    if (sub === "rm") {
+        const ctx = await context(resolve(args[1] ?? "."));
+        if (!ctx)
+            return 1;
+        const refs = [{ file: "llm:anthropic", key: "remover" }];
+        const verification = await verify(ctx, "llm_rm", refs, opts);
+        if (!verification)
+            return 1;
+        const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/llm/remove", { spaceId: ctx.spaceId, verification, keys: refs });
+        if (!res.ok) {
+            refused(res, "A chave não foi apagada");
+            return 1;
+        }
+        log(res.removed ? "✓ Chave apagada do Omni. As suas perguntas voltam para o modelo do Omni." : "Não havia chave ligada.");
+        return 0;
+    }
+    console.error(LLM_USAGE);
+    return 1;
+}

package/dist/uso.js

@@ -0,0 +1,44 @@
+import { callApi } from "./api.js";
+import { defaultApiUrl, loadToken } from "./config.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+const KEY_LABEL = { omni: "chave do Omni", pessoa: "sua chave" };
+const int = (n) => n.toLocaleString("pt-BR");
+const usd = (n) => `US$ ${n.toFixed(6).replace(/0{1,4}$/, "")}`;
+export function formatUsage(res) {
+    const out = [];
+    const block = (title, s) => {
+        out.push(`${title}: ${s.calls} chamada(s), ${usd(s.costUsd)}`);
+        for (const g of s.groups) {
+            const cache = g.cacheReadTokens || g.cacheWriteTokens ? ` (cache: ${int(g.cacheReadTokens)} lidos, ${int(g.cacheWriteTokens)} gravados)` : "";
+            out.push(`  ${g.route.padEnd(7)} ${`${g.provider}/${g.model}`.padEnd(28)} ${(KEY_LABEL[g.keyOwner] ?? g.keyOwner).padEnd(14)} ${String(g.calls).padStart(4)}x  ${int(g.inputTokens)} entrada${cache}, ${int(g.outputTokens)} saída  ${usd(g.costUsd)}`);
+        }
+    };
+    block(`Hoje (${res.day}, UTC)`, res.today);
+    out.push("");
+    block(`Este mês (${res.month})`, res.thisMonth);
+    out.push("");
+    out.push(res.quota.limit === null
+        ? `Cota do Omni hoje: ${int(res.quota.tokensUsed)} tokens, sem limite no seu plano.`
+        : `Cota do Omni hoje: ${int(res.quota.tokensUsed)} de ${int(res.quota.limit)} tokens.`);
+    return out;
+}
+export async function runUso(args) {
+    if (args.length > 0) {
+        console.error("Uso: omnispace uso   (o uso de modelo da sua conta hoje e no mês)");
+        return 1;
+    }
+    const apiUrl = defaultApiUrl();
+    const token = await loadToken(apiUrl);
+    if (!token) {
+        console.error("Nenhuma sessão da CLI nesta máquina. Para entrar: omnispace login");
+        return 1;
+    }
+    const res = await callApi(apiUrl, token, "/api/cli/usage", {}, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!res.ok) {
+        console.error(`Falha ao ler o uso: ${res.error}`);
+        return 1;
+    }
+    for (const line of formatUsage(res))
+        console.log(line);
+    return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnispace",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "Omni CLI (alpha): transforma uma pasta da sua máquina em um espaço Omni e sincroniza entre máquinas.",
   "type": "module",
   "bin": {