omnispace 0.5.1 → 0.5.2

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/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.5.2",
   "description": "Omni CLI (alpha): transforma uma pasta da sua máquina em um espaço Omni e sincroniza entre máquinas.",
   "type": "module",
   "bin": {