omnispace 0.12.0 → 0.13.0

package/README.md

@@ -91,6 +91,14 @@ npx -y omnispace@latest permissoes
 npx -y omnispace@latest permissoes set slack send_message bloqueado
 ```
 
+Perguntar sobre o espaço. A resposta usa a versão publicada, com as fontes (arquivo e versão) e os limites da consulta:
+
+```
+npx -y omnispace@latest ask "Qual foi a última decisão deste projeto?"
+```
+
+Com conectores ligados no espaço, o agente também consulta os conectores: leitura automática roda na hora e aparece como `[C1]`, com o horário da consulta. Uma ação que pede confirmação (como criar uma task ou mandar uma mensagem) não roda sozinha: a CLI mostra o pedido inteiro e pergunta `Executar? [s/n]`. Só `s` executa, uma vez; o pedido vale 10 minutos. Sem terminal, nada é executado.
+
 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
@@ -110,5 +118,6 @@ 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.
 
+- Chaves que formam um conector já ligam o conector do espaço, depois de um teste de conexão: Supabase com `<PREFIXO>_URL` e `<PREFIXO>_SERVICE_ROLE_KEY` (ou `_SERVICE_KEY`), como `SUPABASE_URL` ou `SUPABASE_TOOLS_URL`; ClickUp com o token (`CLICKUP_API_KEY` ou `CLICKUP_<NOME>_TOKEN`) e o `CLICKUP_TEAM_ID`. Se houver mais de um projeto para o mesmo conector, a CLI pergunta qual liga.
 - `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

@@ -1,4 +1,5 @@
 import { basename, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
 import { callApi } from "./api.js";
 import { loadToken, readSpaceConfig } from "./config.js";
 export const ASK_USAGE = 'Uso: omnispace ask "<pergunta>" [pasta] [--fontes] [--detalhes]';
@@ -19,6 +20,32 @@ export function parseAskArgs(rest, cwd = process.cwd()) {
         details: rest.includes("--detalhes"),
     };
 }
+/**
+ * Text that came from the model or a connector, made safe for the terminal: no escape sequences or
+ * control characters (an ANSI code could hide part of what the person is about to confirm).
+ */
+export function terminalSafe(text) {
+    return text.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
+}
+const hhmm = (iso) => {
+    const d = new Date(iso);
+    return Number.isNaN(d.getTime()) ? iso : d.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" });
+};
+/** A pending request shown in full: connector, action and every field of the input, as it will run. */
+export function formatPending(p) {
+    const out = [`Pedido ${terminalSafe(p.ref)}, aguardando sua decisão (vale até ${hhmm(p.expiresAt)}):`, `  ${terminalSafe(p.connector)}: ${terminalSafe(p.actionName)} (${terminalSafe(p.action)})`];
+    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 text = typeof value === "string" ? value : JSON.stringify(value);
+        const lines = terminalSafe(text ?? "").split("\n");
+        out.push(`    ${terminalSafe(key)}: ${lines[0]}`);
+        for (const line of lines.slice(1))
+            out.push(`      ${line}`);
+    }
+    if (Object.keys(input).length === 0)
+        out.push("    (sem entrada)");
+    return out;
+}
 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) {
@@ -35,16 +62,24 @@ export function formatAsk(res, opts) {
         consultedList();
     }
     else {
-        out.push("Resposta:", res.answer ?? "", "");
+        out.push("Resposta:", terminalSafe(res.answer ?? ""), "");
         const sources = res.sources ?? [];
+        const calls = res.connectorCalls ?? [];
         if (sources.length > 0) {
             out.push("Fontes:");
             for (const s of sources)
                 out.push(`  [${s.id}] ${s.path}  (versão ${s.version})`);
         }
-        else {
+        else if (!calls.some((c) => c.cited)) {
             out.push("Fontes: nenhuma citada. Esta resposta não se apoia em arquivo do espaço.");
         }
+        if (calls.length > 0) {
+            out.push("Conectores consultados:");
+            for (const c of calls) {
+                const status = c.ok ? "" : `, falhou: ${terminalSafe(c.error ?? "sem detalhe")}`;
+                out.push(`  [${c.id}] ${terminalSafe(c.connector)}, ${terminalSafe(c.actionName)}  (${hhmm(c.at)}${c.cited ? "" : ", não citado"}${status})`);
+            }
+        }
     }
     out.push("", "Limites:");
     for (const limit of res.limits)
@@ -70,12 +105,50 @@ export function formatAsk(res, opts) {
     }
     return out;
 }
+async function askTerminal(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
 /**
- * `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.
+ * The s/n for each pending request (C4): the person sees it in full and decides. Only "s" runs it;
+ * anything else is a refusal. Without a terminal nothing is asked and nothing runs: the request
+ * just expires. The confirmation is never retried: it runs an action.
  */
-export async function askSpace(args) {
+export async function decidePending(pending, ctx, opts) {
+    if (pending.length === 0)
+        return;
+    const interactive = opts.interactive ?? Boolean(process.stdin.isTTY);
+    for (const p of pending) {
+        for (const line of formatPending(p))
+            console.log(line);
+        if (!interactive) {
+            console.log("  Nada foi executado: sem terminal para confirmar. O pedido vence sozinho; para fazer, rode a pergunta de novo num terminal.\n");
+            continue;
+        }
+        const answer = (await (opts.ask ?? askTerminal)("  Executar? [s/n] ")).trim().toLowerCase();
+        const decision = answer === "s" || answer === "sim" ? "s" : "n";
+        const res = await callApi(ctx.apiUrl, ctx.token, "/api/cli/actions/confirm", { spaceId: ctx.spaceId, requestId: p.id, decision });
+        if (decision === "n") {
+            console.log(res.ok ? "  Recusado. Nada foi executado.\n" : `  ${terminalSafe(String(res.error))}\n`);
+            continue;
+        }
+        if (res.ok) {
+            console.log("  ✓ Executado.");
+            if (typeof res.output === "string")
+                console.log(`  Resultado: ${terminalSafe(res.output)}`);
+            console.log("");
+        }
+        else {
+            console.log(`  ✗ Não executado: ${terminalSafe(String(res.error))}\n`);
+        }
+    }
+}
+export async function askSpace(args, opts = {}) {
     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).`);
@@ -107,9 +180,10 @@ export async function askSpace(args) {
         return 1;
     }
     console.log("");
-    const opts = { baseVersion: config.baseVersion, sourcesOnly: args.sourcesOnly, details: args.details };
-    for (const line of formatAsk(res, opts))
+    const answer = res;
+    for (const line of formatAsk(answer, { baseVersion: config.baseVersion, sourcesOnly: args.sourcesOnly, details: args.details }))
         console.log(line);
     console.log("");
+    await decidePending(answer.pending ?? [], { apiUrl: config.apiUrl, token, spaceId: config.spaceId }, opts);
     return 0;
 }

package/dist/env-connectors.js

@@ -0,0 +1,88 @@
+// Copy of apps/omni/src/lib/env-connectors.ts (C4 item 1, docs/plan/c4-ferramentas-no-ask.md): the
+// server decides what it binds; the CLI uses the same rules only to ask, before sending, which
+// group turns on the connector when the chosen keys have more than one. Change both together; the
+// tests on each side use the same cases.
+const SUPABASE_KEY_SUFFIXES = ["_SERVICE_ROLE_KEY", "_SERVICE_KEY"];
+const CLICKUP_TOKEN = /^CLICKUP(?:_[A-Z0-9]+)*_(?:API_KEY|API_TOKEN|TOKEN)$/;
+const CLICKUP_TEAM_KEYS = ["CLICKUP_TEAM_ID", "CLICKUP_WORKSPACE_ID"];
+/**
+ * Supabase: `<P>_URL` with `<P>_SERVICE_ROLE_KEY` or `<P>_SERVICE_KEY`, where P has SUPABASE in it
+ * (SUPABASE, SUPABASE_TOOLS, NOVODASH_SUPABASE...). `NEXT_PUBLIC_<P>_URL` counts as `<P>_URL`, and
+ * `<P>_URL` wins when both exist. ClickUp: a token key (`CLICKUP_API_KEY`, `CLICKUP_API_TOKEN`,
+ * `CLICKUP_TOKEN`, `CLICKUP_<X>_TOKEN`) with `CLICKUP_TEAM_ID` (or `CLICKUP_WORKSPACE_ID`).
+ */
+export function detectEnvGroups(keyNames) {
+    const keys = new Set(keyNames);
+    const groups = [];
+    const partial = [];
+    // Supabase
+    const urlByPrefix = new Map();
+    for (const key of keys) {
+        const m = /^(?:NEXT_PUBLIC_)?(.*SUPABASE.*)_URL$/.exec(key);
+        if (!m)
+            continue;
+        const prefix = m[1];
+        const current = urlByPrefix.get(prefix);
+        if (!current || current.startsWith("NEXT_PUBLIC_"))
+            urlByPrefix.set(prefix, key);
+    }
+    for (const [prefix, urlKey] of [...urlByPrefix].sort(([a], [b]) => a.localeCompare(b))) {
+        const serviceKey = SUPABASE_KEY_SUFFIXES.map((s) => `${prefix}${s}`).find((k) => keys.has(k));
+        if (!serviceKey)
+            continue;
+        groups.push({ connectorId: "supabase", label: prefix, credential: { service_role_key: serviceKey }, config: { project_url: urlKey } });
+    }
+    if (!groups.some((g) => g.connectorId === "supabase")) {
+        const loose = [...keys]
+            .filter((k) => /SUPABASE/.test(k) && (/_URL$/.test(k) || SUPABASE_KEY_SUFFIXES.some((s) => k.endsWith(s))))
+            .sort();
+        // A public URL alone is what every Supabase front end has: not a half-done connector.
+        if (loose.some((k) => !k.startsWith("NEXT_PUBLIC_")))
+            partial.push({ connectorId: "supabase", keys: loose });
+    }
+    // ClickUp
+    const tokens = [...keys].filter((k) => CLICKUP_TOKEN.test(k)).sort();
+    const team = CLICKUP_TEAM_KEYS.find((k) => keys.has(k));
+    if (tokens.length > 0 && team) {
+        for (const token of tokens) {
+            groups.push({ connectorId: "clickup", label: token, credential: { api_key: token }, config: { team_id: team } });
+        }
+    }
+    else if (tokens.length > 0 || team) {
+        partial.push({ connectorId: "clickup", keys: [...tokens, ...(team ? [team] : [])] });
+    }
+    return { groups, partial };
+}
+/**
+ * The group that turns on each connector: the only one, or the one the person picked. `null` in
+ * `choice` means the person said none. More than one and no valid pick: ambiguous, nothing is bound.
+ */
+export function chooseGroups(groups, choice = {}) {
+    const chosen = [];
+    const ambiguous = [];
+    const byConnector = new Map();
+    for (const g of groups)
+        byConnector.set(g.connectorId, [...(byConnector.get(g.connectorId) ?? []), g]);
+    for (const [connectorId, list] of byConnector) {
+        if (connectorId in choice) {
+            const picked = choice[connectorId];
+            if (picked === null)
+                continue;
+            const match = list.find((g) => g.label === picked);
+            if (match)
+                chosen.push(match);
+            else
+                ambiguous.push({ connectorId, labels: list.map((g) => g.label) });
+            continue;
+        }
+        if (list.length === 1)
+            chosen.push(list[0]);
+        else
+            ambiguous.push({ connectorId, labels: list.map((g) => g.label) });
+    }
+    return { chosen, ambiguous };
+}
+/** A ClickUp team (workspace) id: digits only. */
+export function isClickUpTeamId(value) {
+    return /^\d{1,20}$/.test(value.trim());
+}

package/dist/env.js

@@ -3,6 +3,7 @@ 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 { chooseGroups, detectEnvGroups } from "./env-connectors.js";
 import { openBrowser } from "./login.js";
 import { RETRY_DELAYS_MS } from "./retry.js";
 const STATUS_TEXT = {
@@ -93,6 +94,31 @@ async function readVault(ctx) {
     }
     return { keys: res.keys, connectors: (res.connectors ?? []) };
 }
+const CONNECTOR_NAME = { supabase: "Supabase", clickup: "ClickUp" };
+/**
+ * When the chosen keys hold more than one set for the same connector (the Novo Dash has two Supabase
+ * projects), the person picks which one turns it on; the others stay only in the vault (C4 item 1).
+ * An answer that is not on the list counts as none: nothing is bound by guess.
+ */
+export async function chooseConnectorGroups(accepted, ask, log) {
+    const { groups } = detectEnvGroups(accepted.map((v) => v.key));
+    const { ambiguous } = chooseGroups(groups);
+    const connect = {};
+    for (const { connectorId, labels } of ambiguous) {
+        const name = CONNECTOR_NAME[connectorId];
+        log("");
+        log(`Há mais de um conjunto de chaves para o ${name}. Qual liga o conector ${name} deste espaço?`);
+        labels.forEach((label, i) => log(`  ${i + 1}) ${label}`));
+        log("  n) nenhum (as chaves ficam só no cofre)");
+        const answer = (await ask(`Escolha [1-${labels.length}/n] `)).trim().toLowerCase();
+        const index = Number.parseInt(answer, 10);
+        const picked = /^\d+$/.test(answer) && index >= 1 && index <= labels.length ? labels[index - 1] : null;
+        if (!picked && answer !== "n")
+            log(`Resposta fora da lista: o ${name} não será ligado agora.`);
+        connect[connectorId] = picked;
+    }
+    return connect;
+}
 async function push(root, opts) {
     const log = opts.log ?? ((line) => console.log(line));
     const ask = opts.ask ?? askTerminal;
@@ -133,6 +159,7 @@ async function push(root, opts) {
         log("\nNada escolhido. Nada foi enviado.");
         return 0;
     }
+    const connect = await chooseConnectorGroups(accepted, ask, log);
     const keys = accepted.map(({ file, key }) => ({ file, key }));
     const deviceCode = await verify(ctx, "env_push", keys, opts);
     if (!deviceCode)
@@ -141,6 +168,7 @@ async function push(root, opts) {
         spaceId: ctx.spaceId,
         verification: deviceCode,
         entries: accepted.map(({ file, key, value }) => ({ file, key, value })),
+        ...(Object.keys(connect).length > 0 ? { connect } : {}),
     });
     if (!res.ok) {
         refused(res, "O cofre recusou o envio");

package/package.json

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