omnispace 0.1.0 → 0.2.0

package/README.md

@@ -1,37 +1,49 @@
-# omnispace (alpha)
-
-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. Hoje existem `init` e `sync --push`. Baixar em outra máquina (`clone` e `sync --pull`) vem na próxima versão.
-
-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:
-
-```
-npx -y omnispace@latest init . --link <código>
-```
-
-Só ler a pasta, sem vincular nem enviar nada:
-
-```
-npx -y omnispace@latest init . --scan-only
-```
-
-Publicar uma nova versão do espaço no servidor:
-
-```
-npx -y omnispace@latest sync . --push
-```
-
-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.
-- 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`. O token de acesso fica em `~/.omni/credentials.json`, fora de qualquer projeto.
+# omnispace (alpha)
+
+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`. Quando a mesma parte de um arquivo muda nas duas máquinas, o `sync --pull` para sem mexer na pasta; juntar as duas versões automaticamente vem numa próxima versão.
+
+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:
+
+```
+npx -y omnispace@latest init . --link <código>
+```
+
+Só ler a pasta, sem vincular nem enviar nada:
+
+```
+npx -y omnispace@latest init . --scan-only
+```
+
+Publicar uma nova versão do espaço no servidor:
+
+```
+npx -y omnispace@latest sync . --push
+```
+
+Trazer para a pasta a versão mais nova do servidor:
+
+```
+npx -y omnispace@latest sync . --pull
+```
+
+Baixar um espaço da sua conta em outra máquina (o código aparece no site, em "Baixar em outra máquina"; a pasta é criada):
+
+```
+npx -y omnispace@latest clone <código> "nome-da-pasta"
+```
+
+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.
+- 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 `.omni/tmp/` durante um download, apagada no fim). O token de acesso fica em `~/.omni/credentials.json`, fora de qualquer projeto.

package/dist/api.js

@@ -0,0 +1,11 @@
+/** POST to the Omni server. `token` is the CLI bearer token from ~/.omni/credentials.json, if any. */
+export async function callApi(apiUrl, token, path, body) {
+    const headers = { "content-type": "application/json" };
+    if (token)
+        headers.authorization = `Bearer ${token}`;
+    const response = await fetch(`${apiUrl}${path}`, { method: "POST", headers, body: JSON.stringify(body) });
+    const json = (await response.json().catch(() => ({})));
+    if (!response.ok)
+        return { ok: false, status: response.status, error: json.error ?? `HTTP ${response.status}`, ...json };
+    return { ok: true, status: response.status, ...json };
+}

package/dist/config.js

@@ -1,5 +1,5 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
+import { homedir, hostname } from "node:os";
 import { dirname, join } from "node:path";
 // Two places, on purpose:
 // - ~/.omni/credentials.json: the CLI token, per server. Lives in the user's home, outside every
@@ -10,8 +10,13 @@ const DEFAULT_API_URL = "https://omni.tzolkin.cloud";
 export function defaultApiUrl() {
     return process.env.OMNI_API_URL?.replace(/\/$/, "") || DEFAULT_API_URL;
 }
+// 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() {
+    return process.env.OMNI_MACHINE_NAME?.trim() || hostname();
+}
 function credentialsPath() {
-    return join(homedir(), ".omni", "credentials.json");
+    return join(process.env.OMNI_HOME?.trim() || join(homedir(), ".omni"), "credentials.json");
 }
 export function spaceConfigPath(root) {
     return join(root, ".omni", "space.json");

package/dist/include.js

@@ -9,8 +9,13 @@ export const SKIP_DIRS = new Set([
     "node_modules", ".git", ".next", ".vercel", "dist", "build", "out", "coverage",
     ".turbo", ".cache", "venv", ".venv", "__pycache__", ".idea", ".vscode", "target",
 ]);
-// Local state of the Omni link itself: machine specific, never part of the space.
+// Local state of the Omni link itself: machine specific, never part of the space. `.omni/tmp/`
+// holds downloads of an unfinished pull (fatia 3).
 const LOCAL_ONLY = new Set([".omni/space.json"]);
+export const LOCAL_TMP_DIR = ".omni/tmp";
+function isLocalOnly(path) {
+    return LOCAL_ONLY.has(path) || path.startsWith(`${LOCAL_TMP_DIR}/`);
+}
 const TEXT_EXTENSIONS = new Set([
     ".md", ".mdx", ".txt", ".csv", ".tsv", ".json", ".jsonc", ".yaml", ".yml", ".toml", ".xml",
     ".html", ".htm", ".css", ".scss", ".sass", ".less", ".svg",
@@ -113,7 +118,7 @@ export async function buildManifest(root) {
                 return;
             }
             const path = normalizePath(relParts);
-            if (LOCAL_ONLY.has(path))
+            if (isLocalOnly(path))
                 continue;
             if (isSecret(entry.name)) {
                 excluded.push({ path, reason: "segredo" });

package/dist/index.js

@@ -6,18 +6,21 @@ import { scanFolder } from "./scan.js";
 import { printScanReport } from "./report.js";
 import { linkAndSubmit } from "./link.js";
 import { pushSpace } from "./sync.js";
+import { cloneSpace, pullSpace } from "./pull.js";
 import { buildManifest } from "./include.js";
 import { printSyncPreview } from "./report.js";
-const USAGE = `
-Omni CLI
-
-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 sync [pasta] --push [--yes]  publica uma nova versão do espaço no servidor
-
-Gravar a estrutura padrão na pasta entra num próximo passo da Etapa técnica 1 —
-por enquanto quem decide o que fazer com o que foi varrido é a tela de revisão.
+const USAGE = `
+Omni CLI
+
+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 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
+  omni clone <código> <pasta>       baixa um espaço da sua conta numa pasta nova desta máquina
+
+Gravar a estrutura padrão na pasta entra num próximo passo da Etapa técnica 1 —
+por enquanto quem decide o que fazer com o que foi varrido é a tela de revisão.
 `;
 async function main(argv) {
     const args = argv.slice(2);
@@ -28,6 +31,8 @@ async function main(argv) {
     }
     if (command === "sync")
         return runSync(args.slice(1));
+    if (command === "clone")
+        return runClone(args.slice(1));
     if (command !== "init") {
         console.error(`Comando desconhecido: ${command}`);
         console.log(USAGE.trim());
@@ -79,11 +84,21 @@ async function main(argv) {
     return 0;
 }
 async function runSync(rest) {
-    if (!rest.includes("--push")) {
-        console.error("Por enquanto só existe omni sync --push (baixar vem na próxima fatia).");
+    const push = rest.includes("--push");
+    const pull = rest.includes("--pull");
+    if (push === pull) {
+        console.error("Use omni sync --push (enviar) ou omni sync --pull (baixar).");
         return 1;
     }
     const target = resolve(rest.find((a) => !a.startsWith("-")) ?? process.cwd());
-    return pushSpace(target, { yes: rest.includes("--yes") });
+    return push ? pushSpace(target, { yes: rest.includes("--yes") }) : pullSpace(target);
+}
+async function runClone(rest) {
+    const [code, folder] = rest.filter((a) => !a.startsWith("-"));
+    if (!code || !folder) {
+        console.error("Uso: omni clone <código> <pasta>  (o código aparece no navegador, em Baixar em outra máquina)");
+        return 1;
+    }
+    return cloneSpace(code, folder);
 }
 process.exitCode = await main(process.argv);

package/dist/link.js

@@ -1,5 +1,5 @@
-import { hostname, platform } from "node:os";
-import { defaultApiUrl, saveToken, writeSpaceConfig } from "./config.js";
+import { platform } from "node:os";
+import { defaultApiUrl, machineHostname, saveToken, writeSpaceConfig } from "./config.js";
 function apiUrl(path) {
     return `${defaultApiUrl()}${path}`;
 }
@@ -21,7 +21,7 @@ async function postJson(path, body) {
  */
 export async function linkAndSubmit(code, root, scan) {
     console.log(`\n→ Vinculando com o código ${code}...`);
-    const link = await postJson("/api/cli/link", { code, hostname: hostname(), os: platform() });
+    const link = await postJson("/api/cli/link", { code, hostname: machineHostname(), os: platform() });
     if (!link.ok) {
         console.error(`Falha ao vincular: ${link.error}`);
         process.exitCode = 1;

package/dist/pull.js

@@ -0,0 +1,292 @@
+import { createHash } from "node:crypto";
+import { copyFile, mkdir, readdir, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { callApi } from "./api.js";
+import { buildManifest, hashFile, LOCAL_TMP_DIR } from "./include.js";
+import { defaultApiUrl, loadToken, machineHostname, readSpaceConfig, saveToken, writeSpaceConfig, } from "./config.js";
+/**
+ * Three-way comparison per path (ADR 002): local, base (the version this folder last synced) and
+ * head. Maps are path → hash; a missing path means "does not exist".
+ *
+ * Local equal to head is already applied, which is what makes a re-run after an interruption safe:
+ * files written before the crash are simply skipped the second time.
+ */
+export function planPull(local, base, head) {
+    const plan = { writes: [], deletes: [], localOnly: [], conflicts: [] };
+    const paths = [...new Set([...local.keys(), ...base.keys(), ...head.keys()])].sort();
+    for (const path of paths) {
+        const l = local.get(path);
+        const b = base.get(path);
+        const h = head.get(path);
+        if (l === h)
+            continue;
+        if (l === b) {
+            if (h === undefined)
+                plan.deletes.push(path);
+            else
+                plan.writes.push({ path, hash: h });
+        }
+        else if (h === b) {
+            plan.localOnly.push(path);
+        }
+        else {
+            plan.conflicts.push(path);
+        }
+    }
+    return plan;
+}
+function sha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function toAbs(root, path) {
+    return join(root, ...path.split("/"));
+}
+/** Objects already downloaded by an interrupted pull, re-verified (a half-written file never counts). */
+async function cachedObjects(tmpDir) {
+    const ok = new Set();
+    let names = [];
+    try {
+        names = await readdir(tmpDir);
+    }
+    catch {
+        return ok;
+    }
+    for (const name of names) {
+        if (!/^[0-9a-f]{64}$/.test(name))
+            continue;
+        const abs = join(tmpDir, name);
+        if ((await hashFile(abs)) === name)
+            ok.add(name);
+        else
+            await rm(abs, { force: true });
+    }
+    return ok;
+}
+async function download(url, hash, tmpDir) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status} ao baixar ${hash.slice(0, 12)}`);
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (sha256(bytes) !== hash)
+        throw new Error(`conteúdo baixado não confere com o hash ${hash.slice(0, 12)}`);
+    // Written under a temporary name and renamed: a kill in the middle never leaves a file that
+    // looks complete.
+    const part = join(tmpDir, `${hash}.part`);
+    await writeFile(part, bytes);
+    await rename(part, join(tmpDir, hash));
+}
+/** Removes the folders a deletion left empty, stopping at the space root. */
+async function pruneEmptyDirs(root, path) {
+    const parts = path.split("/").slice(0, -1);
+    while (parts.length > 0) {
+        try {
+            await rmdir(toAbs(root, parts.join("/")));
+        }
+        catch {
+            return; // not empty (or already gone)
+        }
+        parts.pop();
+    }
+}
+function listSome(paths, max = 20) {
+    for (const path of paths.slice(0, max))
+        console.error(`  ${path}`);
+    if (paths.length > max)
+        console.error(`  ... e mais ${paths.length - max}`);
+}
+/**
+ * Brings the folder to the server's head (Proof of Core Sync, fatia 3). Order matters for
+ * interruptions: every object is downloaded and verified into .omni/tmp first, then files are
+ * written, and only at the very end .omni/space.json gets the new base. A run killed anywhere
+ * before that simply runs again.
+ */
+async function pullInto(root, config, token) {
+    if (!config.spaceId) {
+        console.error("Esta pasta ainda não tem espaço publicado. Termine a conta no navegador e rode omni sync --push.");
+        return 1;
+    }
+    console.log("\n→ Lendo a pasta...");
+    const manifest = await buildManifest(root);
+    if (manifest.truncated) {
+        console.error("Pasta grande ou funda demais para sincronizar (limite de 20.000 arquivos e 12 níveis).");
+        return 1;
+    }
+    const tmpDir = toAbs(root, LOCAL_TMP_DIR);
+    const cached = await cachedObjects(tmpDir);
+    const have = [...new Set([...manifest.files.map((f) => f.hash), ...cached])];
+    const pull = await callApi(config.apiUrl, token, "/api/cli/sync/pull", {
+        spaceId: config.spaceId,
+        baseVersion: config.baseVersion,
+        have,
+    });
+    if (!pull.ok) {
+        console.error(`Falha ao consultar o servidor: ${pull.error}`);
+        return 1;
+    }
+    const head = pull.head;
+    const local = new Map(manifest.files.map((f) => [f.path, f.hash]));
+    const base = new Map(pull.base.map((f) => [f.path, f.hash]));
+    const headMap = new Map(pull.files.map((f) => [f.path, f.hash]));
+    const plan = planPull(local, base, headMap);
+    if (head === config.baseVersion) {
+        if (head === 0)
+            console.log("✓ O espaço ainda não tem nenhuma versão publicada. Nada para baixar.\n");
+        else
+            console.log(`✓ Esta pasta já está na versão ${head}, a mais nova do servidor.\n`);
+        if (plan.localOnly.length > 0) {
+            console.log(`  ${plan.localOnly.length} mudança(s) local(is) ainda não enviada(s). Envie com omni sync --push.\n`);
+        }
+        return 0;
+    }
+    if (plan.conflicts.length > 0) {
+        console.error(`\nO servidor está na versão ${head} e estes arquivos mudaram aqui e lá desde a versão ${config.baseVersion}:`);
+        listSome(plan.conflicts);
+        console.error("\nNada foi alterado na pasta. Juntar as duas mudanças automaticamente ainda não existe nesta versão da CLI.");
+        return 1;
+    }
+    // Every object the writes need ends up in .omni/tmp: downloaded, or copied from a local file that
+    // already has that content (a rename on the other machine costs no download).
+    await mkdir(tmpDir, { recursive: true });
+    const localByHash = new Map(manifest.files.map((f) => [f.hash, f.abs]));
+    const urlByHash = new Map(pull.downloads.map((d) => [d.hash, d.url]));
+    const needed = [...new Set(plan.writes.map((w) => w.hash))].filter((h) => !cached.has(h));
+    const toDownload = [];
+    for (const hash of needed) {
+        const localAbs = localByHash.get(hash);
+        if (localAbs)
+            await copyFile(localAbs, join(tmpDir, hash));
+        else if (urlByHash.has(hash))
+            toDownload.push(hash);
+        else {
+            console.error("O servidor não mandou um dos arquivos. Rode de novo.");
+            return 1;
+        }
+    }
+    if (toDownload.length > 0) {
+        let done = 0;
+        const queue = [...toDownload];
+        async function worker() {
+            for (let next = queue.shift(); next; next = queue.shift()) {
+                await download(urlByHash.get(next), next, tmpDir);
+                done++;
+                if (process.stdout.isTTY)
+                    process.stdout.write(`\r  Baixados ${done}/${toDownload.length}`);
+            }
+        }
+        try {
+            await Promise.all(Array.from({ length: Math.min(4, toDownload.length) }, worker));
+        }
+        catch (err) {
+            console.error(`\nDownload interrompido: ${err.message}. Rode de novo: o que já chegou não é baixado outra vez.`);
+            return 1;
+        }
+        console.log(process.stdout.isTTY ? "" : `  Baixados ${done}/${toDownload.length}`);
+    }
+    try {
+        for (const { path, hash } of plan.writes) {
+            const abs = toAbs(root, path);
+            await mkdir(dirname(abs), { recursive: true });
+            await copyFile(join(tmpDir, hash), abs);
+        }
+        for (const path of plan.deletes) {
+            await rm(toAbs(root, path), { force: true });
+            await pruneEmptyDirs(root, path);
+        }
+    }
+    catch (err) {
+        console.error(`\nNão deu para gravar um arquivo: ${err.message}`);
+        console.error("Se ele estiver aberto em outro programa, feche e rode de novo. O que já foi gravado não se perde.");
+        return 1;
+    }
+    await writeSpaceConfig(root, { ...config, baseVersion: head });
+    await rm(tmpDir, { recursive: true, force: true });
+    const ack = await callApi(config.apiUrl, token, "/api/cli/sync/ack", { spaceId: config.spaceId, version: head });
+    if (!ack.ok)
+        console.error(`(aviso) A pasta está na versão ${head}, mas o servidor não registrou: ${ack.error}`);
+    console.log(`✓ Pasta na versão ${head}: ${plan.writes.length} arquivo(s) gravado(s), ${plan.deletes.length} apagado(s).`);
+    if (plan.localOnly.length > 0) {
+        console.log(`  ${plan.localOnly.length} mudança(s) local(is) mantida(s). Envie com omni sync --push.`);
+    }
+    console.log("");
+    return 0;
+}
+/** `omni sync --pull` in a folder that is already a space. */
+export async function pullSpace(root) {
+    const config = await readSpaceConfig(root);
+    if (!config) {
+        console.error("Esta pasta não está vinculada a um espaço. Para baixar um espaço, use omni clone <código> <pasta>.");
+        return 1;
+    }
+    const token = await loadToken(config.apiUrl);
+    if (!token) {
+        console.error(`Nenhum token da CLI para ${config.apiUrl}. Vincule esta máquina de novo.`);
+        return 1;
+    }
+    return pullInto(root, config, token);
+}
+async function isEmptyDir(path) {
+    try {
+        if (!(await stat(path)).isDirectory())
+            return false;
+        return (await readdir(path)).length === 0;
+    }
+    catch {
+        return null; // does not exist
+    }
+}
+/**
+ * `omni clone <código> <pasta>` (fatia 3): installs a space of an existing account on this machine.
+ * Everything happens in a hidden sibling folder, moved to the target only once complete, so a
+ * half-cloned space never looks like a real one. Re-running the same command resumes it, even
+ * though the code is already used: the sibling folder already holds the link.
+ */
+export async function cloneSpace(code, target) {
+    const dest = resolve(target);
+    if (dest.toLowerCase() === resolve(homedir()).toLowerCase()) {
+        console.error("Escolha uma pasta nova para o espaço, não a pasta do seu usuário.");
+        return 1;
+    }
+    const destState = await isEmptyDir(dest);
+    if (destState === false) {
+        console.error(`A pasta ${dest} já existe e não está vazia. Escolha outro nome.`);
+        return 1;
+    }
+    const staging = join(dirname(dest), `.${basename(dest)}.omni-clone`);
+    let config = await readSpaceConfig(staging);
+    if (config) {
+        console.log(`\n→ Retomando o download interrompido em ${staging}...`);
+    }
+    else {
+        const apiUrl = defaultApiUrl();
+        console.log(`\n→ Usando o código ${code}...`);
+        const claim = await callApi(apiUrl, await loadToken(apiUrl), "/api/cli/clone", {
+            code,
+            hostname: machineHostname(),
+            os: platform(),
+            localPath: dest,
+        });
+        if (!claim.ok) {
+            console.error(`Falha ao usar o código: ${claim.error}`);
+            return 1;
+        }
+        if (typeof claim.token === "string")
+            await saveToken(apiUrl, claim.token, claim.machineId);
+        config = { apiUrl, machineId: claim.machineId, spaceId: claim.spaceId, baseVersion: 0 };
+        await writeSpaceConfig(staging, config);
+        console.log(`✓ Máquina vinculada ao espaço ${claim.spaceName}.`);
+    }
+    const token = await loadToken(config.apiUrl);
+    if (!token) {
+        console.error(`Nenhum token da CLI para ${config.apiUrl}. Gere um código novo no navegador e rode de novo.`);
+        return 1;
+    }
+    const result = await pullInto(staging, config, token);
+    if (result !== 0)
+        return result;
+    if (destState === true)
+        await rmdir(dest);
+    await rename(staging, dest);
+    console.log(`✓ Espaço pronto em ${dest}\n`);
+    return 0;
+}

package/dist/sync.js

@@ -3,17 +3,7 @@ import { createInterface } from "node:readline/promises";
 import { buildManifest, MAX_SPACE_BYTES } from "./include.js";
 import { humanSize, printSyncPreview } from "./report.js";
 import { loadToken, readSpaceConfig, writeSpaceConfig } from "./config.js";
-async function callApi(config, token, path, body) {
-    const response = await fetch(`${config.apiUrl}${path}`, {
-        method: "POST",
-        headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
-        body: JSON.stringify(body),
-    });
-    const json = (await response.json().catch(() => ({})));
-    if (!response.ok)
-        return { ok: false, status: response.status, error: json.error ?? `HTTP ${response.status}`, ...json };
-    return { ok: true, status: response.status, ...json };
-}
+import { callApi } from "./api.js";
 async function confirm(question) {
     if (!process.stdin.isTTY)
         return false;
@@ -68,7 +58,7 @@ export async function pushSpace(root, opts) {
     }
     printSyncPreview(manifest);
     const files = manifest.files.map(({ path, hash, size }) => ({ path, hash, size }));
-    const prepare = await callApi(config, token, "/api/cli/sync/prepare", {
+    const prepare = await callApi(config.apiUrl, token, "/api/cli/sync/prepare", {
         spaceId: config.spaceId,
         sessionId: config.spaceId ? undefined : config.sessionId,
         files,
@@ -95,7 +85,7 @@ export async function pushSpace(root, opts) {
     }
     if (head !== config.baseVersion) {
         console.error(`O servidor está na versão ${head} e esta pasta partiu da ${config.baseVersion}. ` +
-            "Baixe as mudanças antes de enviar (omni sync --pull, próxima fatia).");
+            "Baixe as mudanças antes de enviar: omni sync --pull");
         return 1;
     }
     const uploads = prepare.uploads;
@@ -128,9 +118,11 @@ export async function pushSpace(root, opts) {
     if (uploads.length > 0)
         console.log(process.stdout.isTTY ? "" : `  Enviados ${done}/${uploads.length}`);
     console.log(`→ Publicando a versão ${head + 1} (o servidor confere ${files.length} arquivos, pode levar alguns segundos)...`);
-    const commit = await callApi(config, token, "/api/cli/sync/commit", { spaceId, parentVersion: head, files });
+    const commit = await callApi(config.apiUrl, token, "/api/cli/sync/commit", { spaceId, parentVersion: head, files });
     if (!commit.ok) {
         console.error(`Falha ao publicar a versão: ${commit.error}`);
+        if (commit.stale)
+            console.error("Rode omni sync --pull e depois envie de novo.");
         return 1;
     }
     const version = commit.version;

package/package.json

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