omnispace 0.3.1 → 0.5.0

package/README.md

@@ -1,57 +1,57 @@
-# 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`.
-
-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
-```
-
-Se o mesmo arquivo mudou aqui e na outra máquina, o Omni junta sozinho quando as mudanças estão em trechos diferentes. Quando o mesmo trecho mudou dos dois lados, ele pergunta, arquivo por arquivo:
-
-- **manter local**: fica a versão desta máquina, que sobe no próximo envio;
-- **mesclar**: o arquivo é gravado com as duas versões entre marcadores `<<<<<<<` e `>>>>>>>` para você editar; o envio fica bloqueado até os marcadores sumirem;
-- **backup**: entra a versão do servidor e a desta máquina fica guardada em `.omni/backups/`.
-
-Fora de um terminal interativo, escolha para todos com `--conflito=local`, `--conflito=mesclar` ou `--conflito=backup`.
-
-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; `.omni/backups/` e `.omni/conflicts.json` quando há conflito). Nada disso sincroniza. 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`.
+
+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
+```
+
+Se o mesmo arquivo mudou aqui e na outra máquina, o Omni junta sozinho quando as mudanças estão em trechos diferentes. Quando o mesmo trecho mudou dos dois lados, ele pergunta, arquivo por arquivo:
+
+- **manter local**: fica a versão desta máquina, que sobe no próximo envio;
+- **mesclar**: o arquivo é gravado com as duas versões entre marcadores `<<<<<<<` e `>>>>>>>` para você editar; o envio fica bloqueado até os marcadores sumirem;
+- **backup**: entra a versão do servidor e a desta máquina fica guardada em `.omni/backups/`.
+
+Fora de um terminal interativo, escolha para todos com `--conflito=local`, `--conflito=mesclar` ou `--conflito=backup`.
+
+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. Nome de arquivo que o Windows não aceita (como `CON`, `a:b.md` ou terminado em ponto) fica de fora, para o espaço abrir em qualquer sistema.
+- 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.

package/dist/include.js

@@ -11,8 +11,11 @@ export const SKIP_DIRS = new Set([
 ]);
 // Local state of the Omni link itself: machine specific, never part of the space. `.omni/tmp/`
 // holds downloads of an unfinished pull (fatia 3); `.omni/conflicts.json` and `.omni/backups/`
-// are the conflict resolution of this machine (fatia 4).
-const LOCAL_ONLY = new Set([".omni/space.json", ".omni/conflicts.json"]);
+// are the conflict resolution of this machine (fatia 4); `.omni/pull-pending.json` and
+// `.omni/lock` keep an interrupted pull resumable and two runs from overlapping (fatia 5).
+const LOCAL_ONLY = new Set([
+    ".omni/space.json", ".omni/conflicts.json", ".omni/pull-pending.json", ".omni/pull-pending.json.part", ".omni/lock",
+]);
 export const LOCAL_TMP_DIR = ".omni/tmp";
 export const LOCAL_BACKUPS_DIR = ".omni/backups";
 function isLocalOnly(path) {
@@ -34,6 +37,19 @@ export const MAX_FILE_BYTES = 25 * 1024 * 1024;
 export const MAX_SPACE_BYTES = 100 * 1024 * 1024;
 const MAX_FILES = 20000;
 const MAX_DEPTH = 12;
+const WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i;
+/**
+ * A file or folder name every OS can create (fatia 6). Windows refuses reserved device names,
+ * <>:"|?* and control characters, and names ending in a dot or space; NTFS stops at 255. A name
+ * like that made on a Mac would break the pull on Windows, so it never goes up (the server checks
+ * the same rule, apps/omni/src/lib/sync-manifest.ts).
+ */
+export function isPortableName(name) {
+    return (name.length <= 255 &&
+        !/[<>:"|?*\\\x00-\x1f]/.test(name) &&
+        !/[. ]$/.test(name) &&
+        !WINDOWS_RESERVED.test(name));
+}
 /** Files that never leave the machine, with no option to turn them on (ADR 003 item 3, ADR 004). */
 export function isSecret(name) {
     const lower = name.toLowerCase();
@@ -82,6 +98,7 @@ export async function buildManifest(root) {
     const files = [];
     const excluded = [];
     const repos = [];
+    const unreadable = [];
     let totalBytes = 0;
     let seen = 0;
     let truncated = false;
@@ -92,7 +109,14 @@ export async function buildManifest(root) {
             truncated = true;
             return;
         }
-        const entries = await readdir(dir, { withFileTypes: true });
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            unreadable.push(normalizePath(parts) || ".");
+            return;
+        }
         entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
         for (const entry of entries) {
             if (entry.isSymbolicLink())
@@ -130,6 +154,10 @@ export async function buildManifest(root) {
                 excluded.push({ path, reason: "binário ou mídia" });
                 continue;
             }
+            if (!relParts.every(isPortableName)) {
+                excluded.push({ path, reason: "nome que o Windows não aceita" });
+                continue;
+            }
             let size;
             try {
                 size = (await stat(abs)).size;
@@ -141,7 +169,17 @@ export async function buildManifest(root) {
                 excluded.push({ path, reason: "maior que 25 MB" });
                 continue;
             }
-            files.push({ path, hash: await hashFile(abs), size, abs });
+            let hash;
+            try {
+                hash = await hashFile(abs);
+            }
+            catch (err) {
+                if (err.code === "ENOENT")
+                    continue; // vanished meanwhile
+                unreadable.push(path);
+                continue;
+            }
+            files.push({ path, hash, size, abs });
             totalBytes += size;
         }
     }
@@ -152,6 +190,7 @@ export async function buildManifest(root) {
         repos,
         totalBytes,
         collisions: findCaseCollisions(files.map((f) => f.path)),
+        unreadable,
         truncated,
     };
 }

package/dist/index.js

@@ -9,19 +9,20 @@ import { pushSpace } from "./sync.js";
 import { cloneSpace, CONFLICT_CHOICES, 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
-  omni sync [pasta] --pull          traz para a pasta a versão mais nova do servidor
-        [--conflito=local|mesclar|backup]  mesma resposta para todos os conflitos, sem perguntar
-  omni clone <código> <pasta>       baixa um espaço da sua conta numa pasta nova desta máquina
-
-A CLI ainda não reorganiza a sua pasta. O que fazer com o que foi varrido
-é decidido na tela de revisão, no navegador.
+import { LockedError } from "./lock.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
+  omni sync [pasta] --pull          traz para a pasta a versão mais nova do servidor
+        [--conflito=local|mesclar|backup]  mesma resposta para todos os conflitos, sem perguntar
+  omni clone <código> <pasta>       baixa um espaço da sua conta numa pasta nova desta máquina
+
+A CLI ainda não reorganiza a sua pasta. O que fazer com o que foi varrido
+é decidido na tela de revisão, no navegador.
 `;
 async function main(argv) {
     const args = argv.slice(2);
@@ -112,4 +113,10 @@ async function runClone(rest) {
     }
     return cloneSpace(code, folder);
 }
-process.exitCode = await main(process.argv);
+process.exitCode = await main(process.argv).catch((err) => {
+    if (err instanceof LockedError) {
+        console.error(err.message);
+        return 1;
+    }
+    throw err;
+});

package/dist/journal.js

@@ -0,0 +1,81 @@
+import { copyFile, mkdir, readFile, rename, rm, rmdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { LOCAL_TMP_DIR } from "./include.js";
+// The apply step of a pull, written down before the first file is touched (fatia 5). Every
+// decision (merge, conflict choice, backup) is already made and every final content already sits in
+// .omni/tmp by hash, so the journal is just "put this content at this path" or "remove this path".
+// Replaying it is idempotent: a pull killed halfway through writing finishes on the next run,
+// without asking again and without merging a file that already holds the merge.
+/** A write or removal that failed, with the space path (not the long absolute one) and the cause. */
+export class ApplyError extends Error {
+    path;
+    code;
+    constructor(path, code) {
+        super(`${path}: ${code ?? "erro"}`);
+        this.path = path;
+        this.code = code;
+    }
+}
+function journalPath(root) {
+    return join(root, ".omni", "pull-pending.json");
+}
+function toAbs(root, path) {
+    return join(root, ...path.split("/"));
+}
+export async function readJournal(root) {
+    try {
+        const journal = JSON.parse(await readFile(journalPath(root), "utf8"));
+        return Array.isArray(journal?.ops) && typeof journal.head === "number" ? journal : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeJournal(root, journal) {
+    await mkdir(join(root, ".omni"), { recursive: true });
+    const part = `${journalPath(root)}.part`;
+    await writeFile(part, JSON.stringify(journal), "utf8");
+    // Rename is atomic: a journal on disk is always complete.
+    await rename(part, journalPath(root));
+}
+export async function clearJournal(root) {
+    await rm(journalPath(root), { force: true });
+}
+/** Removes the folders a deletion left empty, stopping at the space root. */
+export 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();
+    }
+}
+/**
+ * Carries out every op. `afterOp` exists for tests (simulating a kill after N ops). Throws on the
+ * first file that cannot be written; whatever was done stays done and the journal stays on disk.
+ */
+export async function applyJournal(root, journal, afterOp) {
+    const tmpDir = toAbs(root, LOCAL_TMP_DIR);
+    for (let i = 0; i < journal.ops.length; i++) {
+        const op = journal.ops[i];
+        const abs = toAbs(root, op.path);
+        try {
+            if ("remove" in op) {
+                await rm(abs, { force: true });
+                await pruneEmptyDirs(root, op.path);
+            }
+            else {
+                await mkdir(dirname(abs), { recursive: true });
+                await copyFile(join(tmpDir, op.hash), abs);
+            }
+        }
+        catch (err) {
+            throw new ApplyError(op.path, err.code);
+        }
+        afterOp?.(i);
+    }
+}

package/dist/lock.js

@@ -0,0 +1,63 @@
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join } from "node:path";
+const held = new Set();
+function lockPath(root) {
+    return join(root, ".omni", "lock");
+}
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM: the process exists but belongs to someone else.
+        return err.code === "EPERM";
+    }
+}
+async function readLock(root) {
+    try {
+        const info = JSON.parse(await readFile(lockPath(root), "utf8"));
+        return typeof info?.pid === "number" ? info : null;
+    }
+    catch {
+        return null;
+    }
+}
+export class LockedError extends Error {
+}
+/** Runs `fn` holding the folder lock. Reentrant within one process (pull offering a push). */
+export async function withLock(root, fn) {
+    const key = root.toLowerCase();
+    if (held.has(key))
+        return fn();
+    const info = { pid: process.pid, host: hostname(), startedAt: new Date().toISOString() };
+    for (let attempt = 0;; attempt++) {
+        try {
+            await writeFile(lockPath(root), JSON.stringify(info), { flag: "wx" });
+            break;
+        }
+        catch (err) {
+            // No .omni/ at all: not a space, nothing to protect (fn itself reports it). Never create it here.
+            if (err.code === "ENOENT")
+                return fn();
+            if (err.code !== "EEXIST" || attempt > 0)
+                throw err;
+            const current = await readLock(root);
+            // A lock from another host (a synced or shared folder) cannot be checked: trust it.
+            if (current && (current.host !== info.host || isAlive(current.pid))) {
+                throw new LockedError(`Outro omni sync está rodando nesta pasta (processo ${current.pid}, desde ${current.startedAt}). ` +
+                    "Espere ele terminar e rode de novo. Se nenhum estiver rodando, apague .omni/lock.");
+            }
+            await rm(lockPath(root), { force: true }); // stale: its process is gone
+        }
+    }
+    held.add(key);
+    try {
+        return await fn();
+    }
+    finally {
+        held.delete(key);
+        await rm(lockPath(root), { force: true });
+    }
+}

package/dist/pull.js

@@ -7,7 +7,10 @@ import { callApi } from "./api.js";
 import { buildManifest, hashFile, LOCAL_BACKUPS_DIR, LOCAL_TMP_DIR } from "./include.js";
 import { mergeText } from "./merge.js";
 import { addConflicts } from "./conflicts.js";
+import { ApplyError, applyJournal, clearJournal, readJournal, writeJournal } from "./journal.js";
+import { withLock } from "./lock.js";
 import { pushSpace } from "./sync.js";
+import { printUnreadable } from "./report.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
@@ -108,19 +111,6 @@ export async function download(url, hash, tmpDir, retryDelaysMs = [1000, 3000, 8
     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, out = console.error) {
     for (const path of paths.slice(0, max))
         out(`  ${path}`);
@@ -128,17 +118,10 @@ function listSome(paths, max = 20, out = console.error) {
         out(`  ... e mais ${paths.length - max}`);
 }
 /** Local changes not on the server yet, one per line, marking the ones deleted here. */
-function listPending(paths, local) {
-    listSome(paths.map((p) => (local.has(p) ? `  ${p}` : `  ${p} (apagado aqui)`)), 20, console.log);
+function listPending(pending) {
+    listSome(pending.map((p) => (p.deletedHere ? `  ${p.path} (apagado aqui)` : `  ${p.path}`)), 20, console.log);
 }
 export const CONFLICT_CHOICES = ["local", "mesclar", "backup"];
-/** Files a pull wrote or removed, counting the ones settled by merge, backup or a conflict choice. */
-export function countApplied(plan, resolutions) {
-    return {
-        written: plan.writes.length + resolutions.filter((r) => !r.remove && (r.hash !== undefined || r.text !== undefined)).length,
-        deleted: plan.deletes.length + resolutions.filter((r) => r.remove).length,
-    };
-}
 /** The question for each kind of conflict, with one label per choice (local, mesclar, backup). */
 function promptFor(conflict) {
     switch (conflict.kind) {
@@ -236,33 +219,109 @@ function backupStamp() {
 /**
  * Brings the folder to the server's head (Proof of Core Sync, fatias 3 e 4). Order matters for
  * interruptions: every object is downloaded and verified into .omni/tmp first, every conflict is
- * decided before anything is written, and only at the very end .omni/space.json gets the new base.
- * A run killed anywhere before that simply runs again.
+ * decided before anything is written, and the writes themselves go through a journal (journal.ts):
+ * a run killed while writing finishes them on the next run. Only at the very end .omni/space.json
+ * gets the new base. One run per folder at a time (lock.ts).
  *
  * Files changed on both sides are merged line by line against the base; what still collides is
  * settled with one of the three options of ADR 002 (manter local, mesclar, backup), asked per file
  * in a terminal or given once with --conflito.
  */
 async function pullInto(root, config, token, opts = {}) {
-    const asker = makeAsker();
+    return withLock(root, async () => {
+        const asker = makeAsker();
+        try {
+            return await pullWith(root, config, token, opts, asker);
+        }
+        finally {
+            asker.close();
+        }
+    });
+}
+/** 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 });
+    if (!res.ok)
+        console.error(`(aviso) A pasta está na versão ${version}, mas o servidor não registrou: ${res.error}`);
+}
+/**
+ * Carries out a journal and closes the pull: new base in .omni/space.json, journal and .omni/tmp
+ * removed, server told. Used right after planning and, after an interruption, on the next run.
+ */
+async function finishPull(root, config, token, journal, opts, asker) {
+    const tmpDir = toAbs(root, LOCAL_TMP_DIR);
+    const crashAfter = Number(process.env.OMNI_TEST_CRASH_AFTER_OPS); // tests only: simulated kill
     try {
-        return await pullWith(root, config, token, opts, asker);
+        await applyJournal(root, journal, (i) => {
+            if (i + 1 === crashAfter)
+                process.exit(137);
+        });
+    }
+    catch (err) {
+        const busy = err instanceof ApplyError && ["EBUSY", "EPERM", "EACCES"].includes(err.code ?? "");
+        const what = err instanceof ApplyError ? err.path : "um arquivo";
+        const why = busy ? "está aberto em outro programa ou sem permissão" : err.message;
+        console.error(`\nNão deu para gravar ${what}: ${why}.`);
+        console.error("Feche o que estiver usando o arquivo e rode de novo: o pull continua de onde parou.");
+        return 1;
+    }
+    // Again after the writes: a push run during the interruption may have dropped a path from the
+    // list because its markers were not on disk yet.
+    await addConflicts(root, journal.marked);
+    await writeSpaceConfig(root, { ...config, baseVersion: journal.head });
+    await clearJournal(root);
+    await rm(tmpDir, { recursive: true, force: true });
+    await ack(config, token, journal.head);
+    console.log(`✓ Pasta na versão ${journal.head}: ${journal.written} arquivo(s) gravado(s), ${journal.deleted} apagado(s).`);
+    if (journal.autoMerged > 0)
+        console.log(`  ${journal.autoMerged} arquivo(s) mudaram dos dois lados e foram juntados sozinhos.`);
+    if (journal.backupDir) {
+        console.log(`  Versão desta máquina guardada em ${journal.backupDir} (${journal.backedUp} arquivo(s)).`);
+    }
+    if (journal.marked.length > 0) {
+        console.log("  Arquivos com marcadores para editar à mão (o envio fica bloqueado até eles sumirem):");
+        for (const path of journal.marked)
+            console.log(`    ${path}`);
     }
-    finally {
-        asker.close();
+    if (journal.pendingPush.length > 0 && journal.marked.length === 0) {
+        console.log(`  ${journal.pendingPush.length} mudança(s) desta máquina ainda não estão no servidor:`);
+        listPending(journal.pendingPush);
+        if (process.stdin.isTTY && !opts.conflito) {
+            const answer = await asker.ask("Enviar agora? (s/n) ");
+            if (answer === "s" || answer === "sim")
+                return pushSpace(root, { yes: true });
+        }
+        console.log("  Envie com omni sync --push.");
     }
+    console.log("");
+    return 0;
 }
 async function pullWith(root, config, token, opts, asker) {
     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;
     }
+    // A pull that stopped while writing files: finish exactly what it had decided, nothing new.
+    const pending = await readJournal(root);
+    if (pending) {
+        const staged = await cachedObjects(toAbs(root, LOCAL_TMP_DIR));
+        if (pending.ops.every((op) => "remove" in op || staged.has(op.hash))) {
+            console.log(`\n→ Terminando de aplicar a versão ${pending.head} (um pull anterior parou no meio)...`);
+            return finishPull(root, config, token, pending, opts, asker);
+        }
+        // Staged content gone (someone cleaned .omni/tmp): plan again from scratch, the base is unchanged.
+        await clearJournal(root);
+    }
     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;
     }
+    if (manifest.unreadable.length > 0) {
+        printUnreadable(manifest.unreadable, "Nada foi alterado na pasta.");
+        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])];
@@ -287,9 +346,12 @@ async function pullWith(root, config, token, opts, asker) {
             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):`);
-            listPending(plan.localOnly, local);
+            listPending(plan.localOnly.map((path) => ({ path, deletedHere: !local.has(path) })));
             console.log("  Envie com omni sync --push.\n");
         }
+        // A run cut off between writing the base and telling the server leaves the server behind.
+        if (head > 0 && pull.synced !== head)
+            await ack(config, token, head);
         return 0;
     }
     // Every object needed ends up in .omni/tmp: the head content of what gets written, plus base and
@@ -379,84 +441,68 @@ async function pullWith(root, config, token, opts, asker) {
             resolutions.push(resolveConflict(conflict, choice));
         }
     }
+    // Everything is decided. Before touching any file of the space: take the backups, stage the final
+    // content of every path in .omni/tmp (by hash) and write the journal. From here on a kill only
+    // means the next run replays the journal.
+    const journal = await buildJournal(root, head, plan, resolutions, local, autoMerged);
+    if (!journal)
+        return 1;
+    await writeJournal(root, journal);
+    await addConflicts(root, journal.marked);
+    return finishPull(root, config, token, journal, opts, asker);
+}
+export async function buildJournal(root, head, plan, resolutions, local, autoMerged) {
+    const tmpDir = toAbs(root, LOCAL_TMP_DIR);
+    const ops = [...plan.writes, ...plan.deletes.map((path) => ({ path, remove: true }))];
     const stamp = backupStamp();
-    const backedUp = [];
+    let backedUp = 0;
     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);
-        }
         for (const r of resolutions) {
-            const abs = toAbs(root, r.path);
             if (r.backup) {
                 const copy = toAbs(root, `${LOCAL_BACKUPS_DIR}/${stamp}/${r.path}`);
                 await mkdir(dirname(copy), { recursive: true });
-                await copyFile(abs, copy);
-                backedUp.push(r.path);
-            }
-            if (r.remove) {
-                await rm(abs, { force: true });
-                await pruneEmptyDirs(root, r.path);
-            }
-            else if (r.hash) {
-                await mkdir(dirname(abs), { recursive: true });
-                await copyFile(join(tmpDir, r.hash), abs);
+                await copyFile(toAbs(root, r.path), copy);
+                backedUp++;
             }
+            if (r.remove)
+                ops.push({ path: r.path, remove: true });
+            else if (r.hash)
+                ops.push({ path: r.path, hash: r.hash });
             else if (r.text !== undefined) {
-                await mkdir(dirname(abs), { recursive: true });
-                await writeFile(abs, r.text, "utf8");
+                const bytes = Buffer.from(r.text, "utf8");
+                const hash = sha256(bytes);
+                await writeFile(join(tmpDir, hash), bytes);
+                ops.push({ path: r.path, hash });
             }
         }
     }
     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;
-    }
-    const marked = resolutions.filter((r) => r.markers).map((r) => r.path);
-    await addConflicts(root, marked);
-    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}`);
-    const applied = countApplied(plan, resolutions);
-    console.log(`✓ Pasta na versão ${head}: ${applied.written} arquivo(s) gravado(s), ${applied.deleted} apagado(s).`);
-    if (autoMerged > 0)
-        console.log(`  ${autoMerged} arquivo(s) mudaram dos dois lados e foram juntados sozinhos.`);
-    if (backedUp.length > 0) {
-        console.log(`  Versão desta máquina guardada em ${LOCAL_BACKUPS_DIR}/${stamp}/ (${backedUp.length} arquivo(s)).`);
-    }
-    if (marked.length > 0) {
-        console.log("  Arquivos com marcadores para editar à mão (o envio fica bloqueado até eles sumirem):");
-        for (const path of marked)
-            console.log(`    ${path}`);
-    }
-    const pendingPush = [
-        ...plan.localOnly,
-        ...resolutions.filter((r) => r.pendingPush && !r.markers).map((r) => r.path),
-    ].sort();
-    if (pendingPush.length > 0 && marked.length === 0) {
-        const afterPull = new Map(local);
-        for (const r of resolutions)
-            if (r.remove)
-                afterPull.delete(r.path);
-        console.log(`  ${pendingPush.length} mudança(s) desta máquina ainda não estão no servidor:`);
-        listPending(pendingPush, afterPull);
-        if (process.stdin.isTTY && !opts.conflito) {
-            const answer = await asker.ask("Enviar agora? (s/n) ");
-            if (answer === "s" || answer === "sim")
-                return pushSpace(root, { yes: true });
-        }
-        console.log("  Envie com omni sync --push.");
-    }
-    console.log("");
-    return 0;
+        console.error(`\nNão deu para preparar a gravação: ${err.message}`);
+        console.error("Nada foi alterado na pasta. Rode de novo.");
+        return null;
+    }
+    const afterPull = new Map(local);
+    for (const r of resolutions)
+        if (r.remove)
+            afterPull.delete(r.path);
+    const pendingPush = [...plan.localOnly, ...resolutions.filter((r) => r.pendingPush && !r.markers).map((r) => r.path)]
+        .sort()
+        .map((path) => ({ path, deletedHere: !afterPull.has(path) }));
+    // Removals first. A rename that only changes letter case (Readme.md to README.md) arrives as
+    // "write README.md" + "remove Readme.md"; on Windows both are the same file, so writing first
+    // and removing after would delete the file (fatia 6). Removing first also lets the new name win.
+    const ordered = [...ops.filter((op) => "remove" in op), ...ops.filter((op) => !("remove" in op))];
+    return {
+        head,
+        ops: ordered,
+        written: ops.filter((op) => !("remove" in op)).length,
+        deleted: ops.filter((op) => "remove" in op).length,
+        autoMerged,
+        marked: resolutions.filter((r) => r.markers).map((r) => r.path),
+        backupDir: backedUp > 0 ? `${LOCAL_BACKUPS_DIR}/${stamp}/` : null,
+        backedUp,
+        pendingPush,
+    };
 }
 /** `omni sync --pull` in a folder that is already a space. */
 export async function pullSpace(root, opts = {}) {

package/dist/report.js

@@ -19,6 +19,15 @@ export function humanSize(bytes) {
  * What `omni sync --push` would send (ADR 003 item 6: show what goes up and what stays out, with
  * the reason, before anything leaves the machine). Used by the scan and by the push itself.
  */
+/** Files the manifest could not read. Push and pull stop on them: unread is not the same as deleted. */
+export function printUnreadable(paths, outcome) {
+    console.error("Não deu para ler estes arquivos (abertos em outro programa ou sem permissão):");
+    for (const path of paths.slice(0, 20))
+        console.error(`  ${path}`);
+    if (paths.length > 20)
+        console.error(`  ... e mais ${paths.length - 20}`);
+    console.error(`Feche o programa que está com eles e rode de novo. ${outcome}`);
+}
 export function printSyncPreview(manifest) {
     console.log(`  Sobem: ${manifest.files.length} arquivos de texto · ${humanSize(manifest.totalBytes)}`);
     if (manifest.totalBytes > MAX_SPACE_BYTES) {

package/dist/sync.js

@@ -1,10 +1,12 @@
+import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
 import { buildManifest, MAX_SPACE_BYTES } from "./include.js";
-import { humanSize, printSyncPreview } from "./report.js";
+import { humanSize, printSyncPreview, printUnreadable } from "./report.js";
 import { loadToken, readSpaceConfig, writeSpaceConfig } from "./config.js";
 import { callApi } from "./api.js";
 import { unresolvedConflicts } from "./conflicts.js";
+import { withLock } from "./lock.js";
 async function confirm(question) {
     if (!process.stdin.isTTY)
         return false;
@@ -13,9 +15,16 @@ async function confirm(question) {
     rl.close();
     return answer === "s" || answer === "sim";
 }
-/** Uploads one object straight to Storage through the signed URL (never through the Omni server). */
-async function uploadObject(url, abs) {
+/**
+ * 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.
+ */
+export async function uploadObject(url, abs, path, hash) {
     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" },
@@ -31,6 +40,9 @@ async function uploadObject(url, abs) {
  * the version only exists once all of them are confirmed.
  */
 export async function pushSpace(root, opts) {
+    return withLock(root, () => pushLocked(root, opts));
+}
+async function pushLocked(root, opts) {
     const config = await readSpaceConfig(root);
     if (!config) {
         console.error("Esta pasta ainda não está vinculada. Rode omni init --link <código> antes.");
@@ -55,6 +67,10 @@ export async function pushSpace(root, opts) {
         console.error("Pasta grande ou funda demais para sincronizar (limite de 20.000 arquivos e 12 níveis).");
         return 1;
     }
+    if (manifest.unreadable.length > 0) {
+        printUnreadable(manifest.unreadable, "Nada foi enviado.");
+        return 1;
+    }
     if (manifest.collisions.length > 0) {
         console.error("Há arquivos cujo nome só difere por maiúsculas/minúsculas; no Windows eles colidem:");
         for (const group of manifest.collisions)
@@ -98,8 +114,8 @@ export async function pushSpace(root, opts) {
         return 1;
     }
     const uploads = prepare.uploads;
-    const absByHash = new Map(manifest.files.map((f) => [f.hash, f.abs]));
-    const sizeToSend = uploads.reduce((sum, u) => sum + (manifest.files.find((f) => f.hash === u.hash)?.size ?? 0), 0);
+    const fileByHash = new Map(manifest.files.map((f) => [f.hash, f]));
+    const sizeToSend = uploads.reduce((sum, u) => sum + (fileByHash.get(u.hash)?.size ?? 0), 0);
     if (!opts.yes) {
         const ok = await confirm(`\nEnviar ${uploads.length} arquivo(s) novo(s) ou alterado(s) (${humanSize(sizeToSend)}) e publicar a versão ${head + 1}? (s/n) `);
         if (!ok) {
@@ -111,7 +127,8 @@ export async function pushSpace(root, opts) {
     const queue = [...uploads];
     async function worker() {
         for (let next = queue.shift(); next; next = queue.shift()) {
-            await uploadObject(next.url, absByHash.get(next.hash));
+            const file = fileByHash.get(next.hash);
+            await uploadObject(next.url, file.abs, file.path, next.hash);
             done++;
             if (process.stdout.isTTY)
                 process.stdout.write(`\r  Enviados ${done}/${uploads.length}`);

package/package.json

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