omnispace 0.4.0 → 0.5.0

package/README.md

@@ -50,7 +50,7 @@ No Windows, se o caminho tiver espaço ou apóstrofo, entre na pasta com aspas d
 
 ## 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.
+- 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.

package/dist/include.js

@@ -37,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();
@@ -85,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;
@@ -95,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())
@@ -133,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;
@@ -144,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;
         }
     }
@@ -155,6 +190,7 @@ export async function buildManifest(root) {
         repos,
         totalBytes,
         collisions: findCaseCollisions(files.map((f) => f.path)),
+        unreadable,
         truncated,
     };
 }

package/dist/journal.js

@@ -1,6 +1,21 @@
 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");
 }
@@ -48,13 +63,18 @@ export async function applyJournal(root, journal, afterOp) {
     for (let i = 0; i < journal.ops.length; i++) {
         const op = journal.ops[i];
         const abs = toAbs(root, op.path);
-        if ("remove" in op) {
-            await rm(abs, { force: true });
-            await pruneEmptyDirs(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);
+            }
         }
-        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/pull.js

@@ -7,9 +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 { applyJournal, clearJournal, readJournal, writeJournal } from "./journal.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
@@ -257,8 +258,11 @@ async function finishPull(root, config, token, journal, opts, asker) {
         });
     }
     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 pull continua de onde parou.");
+        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
@@ -314,6 +318,10 @@ async function pullWith(root, config, token, opts, asker) {
         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])];
@@ -443,7 +451,7 @@ async function pullWith(root, config, token, opts, asker) {
     await addConflicts(root, journal.marked);
     return finishPull(root, config, token, journal, opts, asker);
 }
-async function buildJournal(root, head, plan, resolutions, local, autoMerged) {
+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();
@@ -480,9 +488,13 @@ async function buildJournal(root, head, plan, resolutions, local, autoMerged) {
     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,
+        ops: ordered,
         written: ops.filter((op) => !("remove" in op)).length,
         deleted: ops.filter((op) => "remove" in op).length,
         autoMerged,

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

@@ -2,7 +2,7 @@ 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";
@@ -67,6 +67,10 @@ async function pushLocked(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)

package/package.json

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