omnispace 0.5.1 → 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/api.js

@@ -1,11 +1,35 @@
-/** 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) {
+import { isRetryableStatus, RetryableError, warnRetry, withRetry } from "./retry.js";
+/**
+ * POST to the Omni server. `token` is the CLI bearer token from ~/.omni/credentials.json, if any.
+ * With `retryDelaysMs`, a 5xx, a 429 or a dropped connection is tried again; only pass it for calls
+ * that are safe to repeat. A dropped connection that is not retried comes back as status 0.
+ */
+export async function callApi(apiUrl, token, path, body, opts = {}) {
     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 };
+    async function once() {
+        let response;
+        try {
+            response = await fetch(`${apiUrl}${path}`, { method: "POST", headers, body: JSON.stringify(body) });
+        }
+        catch (err) {
+            throw new RetryableError(`conexão com o servidor caiu (${err.message})`);
+        }
+        const json = (await response.json().catch(() => ({})));
+        if (response.ok)
+            return { ok: true, status: response.status, ...json };
+        const result = { ok: false, status: response.status, error: json.error ?? `HTTP ${response.status}`, ...json };
+        if (isRetryableStatus(response.status))
+            throw new RetryableError(result.error, result);
+        return result;
+    }
+    try {
+        return await withRetry(once, opts.retryDelaysMs ?? [], warnRetry);
+    }
+    catch (err) {
+        if (!(err instanceof RetryableError))
+            throw err;
+        return err.result ?? { ok: false, status: 0, error: err.message };
+    }
 }

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/dist/pull.js

@@ -4,6 +4,7 @@ import { createInterface } from "node:readline/promises";
 import { homedir, platform } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { callApi } from "./api.js";
+import { isRetryableStatus, RETRY_DELAYS_MS, RetryableError, withRetry } from "./retry.js";
 import { buildManifest, hashFile, LOCAL_BACKUPS_DIR, LOCAL_TMP_DIR } from "./include.js";
 import { mergeText } from "./merge.js";
 import { addConflicts } from "./conflicts.js";
@@ -70,38 +71,28 @@ async function cachedObjects(tmpDir) {
     }
     return ok;
 }
-class RetryableError extends Error {
-}
 /**
- * A 5xx, a 429 or a dropped connection is usually the Storage having a bad second: the first real
- * clone (Novo Dash, 2026-09-23) stopped at 995/1020 on a single 504. Those are retried with a short
- * backoff before giving up; a 4xx or a wrong hash is not, since trying again cannot fix it.
+ * A 5xx, a 429 or a dropped connection is retried (see retry.ts), quietly: downloads run in
+ * parallel under a progress line. A 4xx or a wrong hash is not, since trying again cannot fix it.
  */
-async function fetchBytes(url, hash, retryDelaysMs) {
-    for (let attempt = 0;; attempt++) {
+function fetchBytes(url, hash, retryDelaysMs) {
+    return withRetry(async () => {
+        let response;
         try {
-            let response;
-            try {
-                response = await fetch(url);
-            }
-            catch (err) {
-                throw new RetryableError(`conexão caiu ao baixar ${hash.slice(0, 12)} (${err.message})`);
-            }
-            if (response.status >= 500 || response.status === 429) {
-                throw new RetryableError(`HTTP ${response.status} ao baixar ${hash.slice(0, 12)}`);
-            }
-            if (!response.ok)
-                throw new Error(`HTTP ${response.status} ao baixar ${hash.slice(0, 12)}`);
-            return new Uint8Array(await response.arrayBuffer());
+            response = await fetch(url);
         }
         catch (err) {
-            if (!(err instanceof RetryableError) || attempt >= retryDelaysMs.length)
-                throw err;
-            await new Promise((r) => setTimeout(r, retryDelaysMs[attempt]));
+            throw new RetryableError(`conexão caiu ao baixar ${hash.slice(0, 12)} (${err.message})`);
         }
-    }
+        const message = `HTTP ${response.status} ao baixar ${hash.slice(0, 12)}`;
+        if (isRetryableStatus(response.status))
+            throw new RetryableError(message);
+        if (!response.ok)
+            throw new Error(message);
+        return new Uint8Array(await response.arrayBuffer());
+    }, retryDelaysMs);
 }
-export async function download(url, hash, tmpDir, retryDelaysMs = [1000, 3000, 8000]) {
+export async function download(url, hash, tmpDir, retryDelaysMs = RETRY_DELAYS_MS) {
     const bytes = await fetchBytes(url, hash, retryDelaysMs);
     if (sha256(bytes) !== hash)
         throw new Error(`conteúdo baixado não confere com o hash ${hash.slice(0, 12)}`);
@@ -240,7 +231,7 @@ async function pullInto(root, config, token, opts = {}) {
 }
 /** Tells the server this folder is on `version` (what the /home machine panel shows). */
 async function ack(config, token, version) {
-    const res = await callApi(config.apiUrl, token, "/api/cli/sync/ack", { spaceId: config.spaceId, version });
+    const res = await callApi(config.apiUrl, token, "/api/cli/sync/ack", { spaceId: config.spaceId, version }, { retryDelaysMs: RETRY_DELAYS_MS });
     if (!res.ok)
         console.error(`(aviso) A pasta está na versão ${version}, mas o servidor não registrou: ${res.error}`);
 }
@@ -325,11 +316,7 @@ async function pullWith(root, config, token, opts, asker) {
     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,
-    });
+    const pull = await callApi(config.apiUrl, token, "/api/cli/sync/pull", { spaceId: config.spaceId, baseVersion: config.baseVersion, have }, { retryDelaysMs: RETRY_DELAYS_MS });
     if (!pull.ok) {
         console.error(`Falha ao consultar o servidor: ${pull.error}`);
         return 1;
@@ -553,6 +540,8 @@ export async function cloneSpace(code, target) {
     else {
         const apiUrl = defaultApiUrl();
         console.log(`\n→ Usando o código ${code}...`);
+        // Never retried: the code is single use, so a second try after a lost answer would only say
+        // "código já usado". The staging folder above is what makes the rest resumable.
         const claim = await callApi(apiUrl, await loadToken(apiUrl), "/api/cli/clone", {
             code,
             hostname: machineHostname(),

package/dist/retry.js

@@ -0,0 +1,38 @@
+/**
+ * Retry for calls that can safely run twice. A 5xx, a 429 or a dropped connection is usually the
+ * server or the Storage having a bad second: the first real clone (Novo Dash, 2026-09-23) stopped
+ * at 995/1020 on a single 504, and the closing test of the Proof of Core Sync (2026-09-25) had a
+ * `prepare` fail once with "Falha ao gerar URL de envio". A 4xx is never retried, since trying
+ * again cannot fix it. Calls that are not safe to repeat (commit, clone) never go through here.
+ */
+/** Waits before the 2nd, 3rd and 4th attempts. */
+export const RETRY_DELAYS_MS = [1000, 3000, 8000];
+/** A failure worth trying again. `result` keeps the last server answer, if there was one. */
+export class RetryableError extends Error {
+    result;
+    constructor(message, result) {
+        super(message);
+        this.result = result;
+    }
+}
+export function isRetryableStatus(status) {
+    return status >= 500 || status === 429;
+}
+/** Warning shown before each new attempt, on stderr so it never mixes with command output. */
+export function warnRetry(err, waitMs) {
+    console.error(`  (servidor instável: ${err.message}; tentando de novo em ${waitMs / 1000}s)`);
+}
+/** Runs `fn`, repeating it after each RetryableError with the given delays; the last one is thrown. */
+export async function withRetry(fn, delaysMs, onRetry) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (!(err instanceof RetryableError) || attempt >= delaysMs.length)
+                throw err;
+            onRetry?.(err, delaysMs[attempt]);
+            await new Promise((r) => setTimeout(r, delaysMs[attempt]));
+        }
+    }
+}

package/dist/sync.js

@@ -7,6 +7,7 @@ import { loadToken, readSpaceConfig, writeSpaceConfig } from "./config.js";
 import { callApi } from "./api.js";
 import { unresolvedConflicts } from "./conflicts.js";
 import { withLock } from "./lock.js";
+import { isRetryableStatus, RETRY_DELAYS_MS, RetryableError, warnRetry, withRetry } from "./retry.js";
 async function confirm(question) {
     if (!process.stdin.isTTY)
         return false;
@@ -19,19 +20,31 @@ async function confirm(question) {
  * Uploads one object straight to Storage through the signed URL (never through the Omni server).
  * The bytes are hashed again right before sending: a file edited after the manifest was built would
  * otherwise land under the old hash, and every later version would reuse that wrong object.
+ * A 5xx, a 429 or a dropped connection is sent again: the PUT is an upsert of the same bytes, and
+ * the commit checks every object anyway.
  */
-export async function uploadObject(url, abs, path, hash) {
+export async function uploadObject(url, abs, path, hash, retryDelaysMs = RETRY_DELAYS_MS) {
     const bytes = await readFile(abs);
     if (createHash("sha256").update(bytes).digest("hex") !== hash) {
         throw new Error(`o arquivo ${path} mudou durante o envio`);
     }
-    const response = await fetch(url, {
-        method: "PUT",
-        headers: { "content-type": "application/octet-stream", "x-upsert": "true" },
-        body: bytes,
-    });
-    if (!response.ok)
-        throw new Error(`HTTP ${response.status} ${await response.text().catch(() => "")}`);
+    await withRetry(async () => {
+        let response;
+        try {
+            response = await fetch(url, {
+                method: "PUT",
+                headers: { "content-type": "application/octet-stream", "x-upsert": "true" },
+                body: bytes,
+            });
+        }
+        catch (err) {
+            throw new RetryableError(`conexão caiu ao enviar ${path} (${err.message})`);
+        }
+        if (response.ok)
+            return;
+        const message = `HTTP ${response.status} ao enviar ${path} ${await response.text().catch(() => "")}`.trim();
+        throw isRetryableStatus(response.status) ? new RetryableError(message) : new Error(message);
+    }, retryDelaysMs, warnRetry);
 }
 /**
  * `omni sync --push` (Proof of Core Sync, fatia 2; docs/plan/adr/002-protocolo-sync.md).
@@ -83,11 +96,7 @@ async function pushLocked(root, opts) {
     }
     printSyncPreview(manifest);
     const files = manifest.files.map(({ path, hash, size }) => ({ path, hash, size }));
-    const prepare = await callApi(config.apiUrl, token, "/api/cli/sync/prepare", {
-        spaceId: config.spaceId,
-        sessionId: config.spaceId ? undefined : config.sessionId,
-        files,
-    });
+    const prepare = await callApi(config.apiUrl, token, "/api/cli/sync/prepare", { spaceId: config.spaceId, sessionId: config.spaceId ? undefined : config.sessionId, files }, { retryDelaysMs: RETRY_DELAYS_MS });
     if (!prepare.ok) {
         console.error(`Falha ao preparar o envio: ${prepare.error}`);
         return 1;
@@ -144,11 +153,16 @@ async function pushLocked(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)...`);
+    // Never retried here: if the server published and only the answer got lost, a second commit would
+    // come back as "stale". The next run recovers instead (prepare sees `unchanged` and adopts the head).
     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.");
+        else if (commit.status === 0 || isRetryableStatus(commit.status)) {
+            console.error("Rode de novo: se a versão chegou a ser publicada, o próximo envio reconhece e não duplica.");
+        }
         return 1;
     }
     const version = commit.version;

package/package.json

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