omnispace 0.5.2 → 0.6.0

package/README.md

@@ -2,13 +2,27 @@
 
 CLI do [Omni](https://omni.tzolkin.cloud): transforma uma pasta da sua máquina em um espaço Omni e sincroniza esse espaço entre máquinas.
 
-> Alpha. Existem `init`, `sync --push`, `sync --pull` e `clone`.
+> Alpha. Existem `login`, `logout`, `whoami`, `init`, `sync --push`, `sync --pull` e `clone`.
 
 Precisa do Node 20 ou mais novo.
 
 ## Uso
 
-Comece pelo site: ele mostra o código de vínculo. Depois, dentro da pasta do espaço:
+Já tem conta no Omni? Entre pelo navegador (a CLI mostra um link e um código; a senha nunca passa pelo terminal):
+
+```
+npx -y omnispace@latest login
+```
+
+A sessão vale 14 dias sem uso, e cada uso renova. `whoami` mostra a conta e até quando a sessão vale; `logout` encerra a sessão e apaga o token desta máquina.
+
+Com a CLI logada, dentro da pasta, o `init` cria o espaço direto na sua conta (só pergunta o nome, que por padrão é o da pasta) e já oferece o primeiro envio:
+
+```
+npx -y omnispace@latest init .
+```
+
+Primeira vez no Omni? Comece pelo site: ele mostra o código de vínculo. Depois, dentro da pasta do espaço:
 
 ```
 npx -y omnispace@latest init . --link <código>
@@ -54,4 +68,5 @@ No Windows, se o caminho tiver espaço ou apóstrofo, entre na pasta com aspas d
 - Nunca sobem: `.env` e variações, chaves (`.pem`, `.key`, `id_rsa`), pastas `.git`, `node_modules` e de build, imagens e mídia.
 - Arquivos `.env` são lidos só para listar os nomes das chaves; nenhum valor é guardado ou enviado.
 - 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.
+- 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).

package/dist/config.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir, hostname } from "node:os";
 import { dirname, join } from "node:path";
 // Two places, on purpose:
@@ -10,6 +10,25 @@ const DEFAULT_API_URL = "https://omni.tzolkin.cloud";
 export function defaultApiUrl() {
     return process.env.OMNI_API_URL?.replace(/\/$/, "") || DEFAULT_API_URL;
 }
+/**
+ * Barrier 1 of pos-marco-conectores.md: tokens (and, later, credentials) only travel over HTTPS.
+ * Plain http is accepted only for a server on this machine (development). Returns the problem, or null.
+ */
+export function insecureApiUrl(url = defaultApiUrl()) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return `OMNI_API_URL não é um endereço válido: ${url}`;
+    }
+    if (parsed.protocol === "https:")
+        return null;
+    const local = ["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname) || parsed.hostname.endsWith(".localhost");
+    if (parsed.protocol === "http:" && local)
+        return null;
+    return `OMNI_API_URL precisa usar https (recebido ${parsed.protocol}//${parsed.host}). http só vale para um servidor nesta máquina.`;
+}
 // OMNI_HOME and OMNI_MACHINE_NAME exist to simulate two machines on one PC (fatia 3): each gets
 // its own credentials and its own row in `machines` (unique per account and hostname).
 export function machineHostname() {
@@ -29,18 +48,37 @@ async function readJson(path) {
         return null;
     }
 }
-async function writeJson(path, value) {
+/**
+ * Written to a temporary file next to the target and renamed over it: a kill in the middle never
+ * leaves a half-written credentials.json or space.json. `mode` 0o600 keeps the token readable only
+ * by the user (ignored on Windows, where the home folder is already private).
+ */
+async function writeJson(path, value, mode) {
     await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    const tmp = `${path}.${process.pid}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode });
+    await rename(tmp, path);
 }
-export async function saveToken(apiUrl, token, machineId) {
+export async function saveToken(apiUrl, token, machineId, email) {
     const all = (await readJson(credentialsPath())) ?? {};
-    all[apiUrl] = { token, machineId };
-    await writeJson(credentialsPath(), all);
+    all[apiUrl] = email ? { token, machineId, email } : { token, machineId };
+    await writeJson(credentialsPath(), all, 0o600);
+}
+export async function loadCredential(apiUrl) {
+    const all = await readJson(credentialsPath());
+    return all?.[apiUrl] ?? null;
 }
 export async function loadToken(apiUrl) {
+    return (await loadCredential(apiUrl))?.token ?? null;
+}
+/** `omnispace logout`: forgets this server's token (the other servers' entries stay). */
+export async function removeToken(apiUrl) {
     const all = await readJson(credentialsPath());
-    return all?.[apiUrl]?.token ?? null;
+    if (!all?.[apiUrl])
+        return false;
+    delete all[apiUrl];
+    await writeJson(credentialsPath(), all, 0o600);
+    return true;
 }
 export function readSpaceConfig(root) {
     return readJson(spaceConfigPath(root));

package/dist/index.js

@@ -10,11 +10,17 @@ import { cloneSpace, CONFLICT_CHOICES, pullSpace } from "./pull.js";
 import { buildManifest } from "./include.js";
 import { printSyncPreview } from "./report.js";
 import { LockedError } from "./lock.js";
-import { defaultApiUrl } from "./config.js";
+import { defaultApiUrl, insecureApiUrl } from "./config.js";
+import { login, logout, printWhoami, whoami } from "./login.js";
+import { initWithAccount } from "./init-account.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 sync [pasta] --push [--yes]  publica uma nova versão do espaço no servidor
@@ -32,6 +38,17 @@ async function main(argv) {
         console.log(USAGE.trim());
         return 0;
     }
+    const insecure = insecureApiUrl();
+    if (insecure) {
+        console.error(insecure);
+        return 1;
+    }
+    if (command === "login")
+        return login({ openBrowser: !args.includes("--sem-navegador") && process.stdout.isTTY });
+    if (command === "logout")
+        return logout();
+    if (command === "whoami")
+        return printWhoami();
     if (command === "sync")
         return runSync(args.slice(1));
     if (command === "clone")
@@ -44,18 +61,31 @@ async function main(argv) {
     const rest = args.slice(1);
     const linkIndex = rest.indexOf("--link");
     const linkCode = linkIndex >= 0 ? rest[linkIndex + 1] : undefined;
-    const positional = rest.filter((a, i) => !a.startsWith("-") && (linkIndex < 0 || i !== linkIndex + 1));
+    const nameIndex = rest.indexOf("--nome");
+    const nameArg = rest.find((a) => a.startsWith("--nome="))?.slice("--nome=".length) ?? (nameIndex >= 0 ? rest[nameIndex + 1] : undefined);
+    const positional = rest.filter((a, i) => !a.startsWith("-") && (linkIndex < 0 || i !== linkIndex + 1) && (nameIndex < 0 || i !== nameIndex + 1));
     const hasScanOnly = rest.includes("--scan-only");
     const target = resolve(positional[0] ?? process.cwd());
-    // Writing to disk is not implemented yet (Etapa técnica 1 segue em aberto), so a run that
-    // asked for neither mode must stop instead of pretending the full flow happened. A bare
-    // `npx omnispace init` is exactly what the LP shows, so it points to where the flow starts.
-    if (!hasScanOnly && !linkCode) {
-        const site = defaultApiUrl();
-        console.log(`
+    // Neither mode asked: with the CLI logged in to an account, the space is created straight there
+    // (fatia 1b). Without it, a bare `npx omnispace init` (what the LP shows) points to the funnel.
+    const accountMode = !hasScanOnly && !linkCode;
+    let me = null;
+    if (accountMode) {
+        const who = await whoami();
+        if (who.ok && who.me.hasAccount) {
+            me = who.me;
+        }
+        else {
+            if (!who.ok && !who.noToken)
+                console.error(`\n${who.error}`);
+            const site = defaultApiUrl();
+            console.log(`
 Omni CLI
 
-Para ligar uma pasta ao Omni, comece pelo navegador:
+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:
@@ -64,7 +94,8 @@ Lá aparece um código (tipo ABCD-2345). Com ele, dentro da pasta do espaço, ro
 Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
   npx -y omnispace@latest init . --scan-only
 `);
-        return 0;
+            return who.ok || who.noToken ? 0 : 1;
+        }
     }
     try {
         const info = await stat(target);
@@ -79,11 +110,13 @@ Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
     }
     // Linking the user's whole home folder happened for real on 2026-09-23 (a missing cd); a space
     // is a work folder inside it, never the home itself.
-    if (linkCode && resolve(target).toLowerCase() === resolve(homedir()).toLowerCase()) {
+    if ((linkCode || me) && resolve(target).toLowerCase() === resolve(homedir()).toLowerCase()) {
         console.error(`Essa é a pasta do seu usuário (${target}), não a de um projeto.`);
         console.error('Entre na pasta do espaço primeiro, com o caminho entre aspas duplas: cd "<caminho da pasta>"');
         return 1;
     }
+    if (me)
+        return initWithAccount(target, me, { name: nameArg, yes: rest.includes("--yes") });
     const scan = await scanFolder(target);
     printScanReport(scan, { linking: Boolean(linkCode) });
     if (linkCode && scan.truncated) {

package/dist/init-account.js

@@ -0,0 +1,83 @@
+import { basename } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { callApi } from "./api.js";
+import { defaultApiUrl, loadToken, readSpaceConfig, writeSpaceConfig } from "./config.js";
+import { printScanReport } from "./report.js";
+import { scanFolder } from "./scan.js";
+import { pushSpace } from "./sync.js";
+async function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * `omnispace init` with the CLI logged in (pós-marco, fatia 1b; decision of Lucas, 2026-09-25):
+ * the space is created straight in the account, no web funnel. Only the name is asked (the folder
+ * name is the default); icon, type and categories keep their defaults and are edited on the web.
+ * Writes only .omni/space.json in the folder, then offers the first push.
+ */
+export async function initWithAccount(root, me, opts) {
+    const existing = await readSpaceConfig(root);
+    if (existing?.spaceId) {
+        console.error("Esta pasta já é um espaço Omni. Para enviar mudanças: omnispace sync . --push");
+        return 1;
+    }
+    if (existing?.sessionId) {
+        console.error("Esta pasta está no meio da criação pelo navegador. Termine lá, ou apague .omni/space.json para começar de novo.");
+        return 1;
+    }
+    const scan = await scanFolder(root);
+    printScanReport(scan, { linking: true });
+    if (scan.truncated) {
+        console.error("A leitura parou antes do fim, então o espaço não foi criado. Aponte a pasta do espaço, não uma pasta acima dela.");
+        return 1;
+    }
+    const suggested = basename(root) || "Meu espaço";
+    let name = opts.name?.trim();
+    if (!name) {
+        if (opts.yes || !process.stdin.isTTY) {
+            name = suggested;
+        }
+        else {
+            name = (await ask(`Nome do espaço [${suggested}]: `)) || suggested;
+        }
+    }
+    if (name.length > 80) {
+        console.error("O nome do espaço pode ter até 80 caracteres.");
+        return 1;
+    }
+    if (!opts.yes) {
+        if (!process.stdin.isTTY) {
+            console.error('Sem terminal para confirmar. Rode de novo com --yes (e --nome "<nome>" se quiser outro nome).');
+            return 1;
+        }
+        const answer = (await ask(`Criar o espaço "${name}" na conta ${me.email ?? ""} e ligar esta pasta a ele? (s/n) `)).toLowerCase();
+        if (answer !== "s" && answer !== "sim") {
+            console.log("Nada foi criado.");
+            return 1;
+        }
+    }
+    const apiUrl = defaultApiUrl();
+    const token = await loadToken(apiUrl);
+    if (!token) {
+        console.error("A sessão da CLI sumiu no meio do caminho. Rode omnispace login.");
+        return 1;
+    }
+    // Not retried: creating a space twice would leave a duplicate in the account.
+    const created = await callApi(apiUrl, token, "/api/cli/spaces", { name, localPath: root, detectedStacks: scan.stacks });
+    if (!created.ok) {
+        console.error(`Falha ao criar o espaço: ${created.error}`);
+        return 1;
+    }
+    await writeSpaceConfig(root, { apiUrl, machineId: me.machineId, spaceId: created.spaceId, baseVersion: 0 });
+    console.log(`✓ Espaço "${created.name}" criado na sua conta. Vínculo gravado em .omni/space.json.`);
+    if (scan.stacks.length > 0) {
+        console.log(`  ${scan.stacks.length} conector(es) preparado(s), desligado(s) até você ligar as credenciais.`);
+    }
+    console.log("\n→ Primeiro envio desta pasta para o espaço:");
+    return pushSpace(root, { yes: opts.yes });
+}

package/dist/login.js

@@ -0,0 +1,113 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import { callApi } from "./api.js";
+import { defaultApiUrl, loadCredential, machineHostname, removeToken, saveToken } from "./config.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+// `omnispace login`, `logout` e `whoami` (pós-marco, fatia 1b; docs/plan/pos-marco-conectores.md).
+// Login pelo código no navegador: a senha nunca passa pelo terminal. A sessão vale 14 dias contados
+// do último uso; parada mais que isso, o servidor recusa e pede login de novo.
+/**
+ * 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) {
+    if (!/^https?:\/\//.test(url))
+        return;
+    const os = platform();
+    const [cmd, args] = os === "win32"
+        ? ["rundll32", ["url.dll,FileProtocolHandler", url]]
+        : os === "darwin"
+            ? ["open", [url]]
+            : ["xdg-open", [url]];
+    try {
+        const child = spawn(cmd, args, { stdio: "ignore", detached: true, windowsHide: true });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch {
+        // No browser here (server, container): the printed URL is enough.
+    }
+}
+export async function login(opts = {}) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const apiUrl = defaultApiUrl();
+    const previous = await loadCredential(apiUrl);
+    const start = await callApi(apiUrl, null, "/api/cli/login/start", { hostname: machineHostname(), os: platform(), machineId: previous?.machineId }, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!start.ok) {
+        console.error(`Falha ao começar o login: ${start.error}`);
+        return 1;
+    }
+    const deviceCode = start.deviceCode;
+    const userCode = start.userCode;
+    const verifyUrl = start.verifyUrl;
+    const expiresAt = Date.now() + start.expiresIn * 1000;
+    const waitMs = opts.pollMs ?? start.interval * 1000;
+    log("");
+    log("Para entrar, abra no navegador:");
+    log(`  ${verifyUrl}`);
+    log("e digite este código:");
+    log(`  ${userCode}`);
+    log("");
+    if (opts.openBrowser)
+        openBrowser(verifyUrl);
+    log("→ Esperando a autorização no navegador (Ctrl+C cancela)...");
+    while (Date.now() < expiresAt) {
+        await new Promise((r) => setTimeout(r, waitMs));
+        const poll = await callApi(apiUrl, null, "/api/cli/login/poll", { deviceCode }, { retryDelaysMs: RETRY_DELAYS_MS });
+        if (poll.ok && poll.state === "pending")
+            continue;
+        if (!poll.ok) {
+            console.error(poll.denied ? "Login recusado no navegador. Nada foi liberado." : `Falha no login: ${poll.error}`);
+            return 1;
+        }
+        await saveToken(apiUrl, poll.token, poll.machineId, poll.email ?? undefined);
+        log(`✓ Entrou como ${poll.email ?? "sua conta"}.`);
+        log("  A sessão vale 14 dias sem uso, e cada uso renova. Para sair: omnispace logout\n");
+        return 0;
+    }
+    console.error("O código expirou antes da autorização. Rode omnispace login de novo.");
+    return 1;
+}
+export async function logout() {
+    const apiUrl = defaultApiUrl();
+    const credential = await loadCredential(apiUrl);
+    if (!credential) {
+        console.log("Nenhuma sessão da CLI nesta máquina.");
+        return 0;
+    }
+    // Revoked on the server first; the local copy goes either way (an expired or revoked token is
+    // useless anyway, and keeping it would only confuse the next command).
+    const res = await callApi(apiUrl, credential.token, "/api/cli/logout", {});
+    await removeToken(apiUrl);
+    if (res.ok)
+        console.log("✓ Sessão encerrada: o token foi revogado no servidor e apagado desta máquina.");
+    else
+        console.log(`✓ Token apagado desta máquina. (O servidor respondeu: ${res.error})`);
+    return 0;
+}
+/** The account behind this machine's token, or the server's refusal (expired, revoked, none). */
+export async function whoami() {
+    const apiUrl = defaultApiUrl();
+    const credential = await loadCredential(apiUrl);
+    if (!credential)
+        return { ok: false, error: "Nenhuma sessão da CLI nesta máquina.", noToken: true };
+    const res = await callApi(apiUrl, credential.token, "/api/cli/whoami", {}, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!res.ok)
+        return { ok: false, error: res.error ?? "falha", expired: Boolean(res.expired) };
+    return { ok: true, me: res };
+}
+export async function printWhoami() {
+    const result = await whoami();
+    if (!result.ok) {
+        console.log(result.error);
+        if (result.noToken || result.expired)
+            console.log("Para entrar: npx -y omnispace@latest login");
+        return 1;
+    }
+    const { me } = result;
+    const until = new Date(me.expiresAt).toLocaleDateString("pt-BR");
+    console.log(me.hasAccount ? `Conta: ${me.email ?? "(sem email)"}` : "Máquina vinculada pelo navegador, conta ainda não criada.");
+    console.log(`Máquina: ${me.machineName ?? me.machineId}`);
+    console.log(`Sessão: vale até ${until} se ficar sem uso (cada uso renova).`);
+    return 0;
+}

package/package.json

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