@iksdev/shard-cli 0.1.1 → 0.1.4

package/bin/shard.js

@@ -4,6 +4,8 @@ const fs = require('fs');
 const fsp = require('fs/promises');
 const os = require('os');
 const path = require('path');
+const { Readable } = require('stream');
+const { pipeline } = require('stream/promises');
 
 const CONFIG_DIR = path.join(os.homedir(), '.shard-cli');
 const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
@@ -17,7 +19,7 @@ function printHelp() {
 Usage:
   shard login --username <name> --password <pass> [--server <url>]
   shard whoami [--server <url>]
-  shard sync <folder> [--server <url>] [--dry-run] [--force]
+  shard sync <folder> [--server <url>] [--dry-run] [--force] [--once] [--interval-ms <n>]
   shard logout
   shard config show
   shard config set-server <url>
@@ -25,6 +27,7 @@ Usage:
 Examples:
   shard login --server http://localhost:3000 --username admin --password secret
   shard sync ./MonDossier
+  shard sync ./MonDossier --once
   shard sync ./MonDossier --dry-run
 `);
 }
@@ -260,6 +263,18 @@ function guessMime(filePath) {
   return map[ext] || 'application/octet-stream';
 }
 
+function formatBytes(bytes) {
+  const value = Number(bytes || 0);
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  let size = value;
+  let idx = 0;
+  while (size >= 1024 && idx < units.length - 1) {
+    size /= 1024;
+    idx += 1;
+  }
+  return `${size.toFixed(idx === 0 ? 0 : 2)} ${units[idx]}`;
+}
+
 async function uploadOneFile(server, token, file) {
   const blob = await fs.openAsBlob(file.absPath, { type: guessMime(file.absPath) });
   const form = new FormData();
@@ -273,10 +288,270 @@ async function uploadOneFile(server, token, file) {
   });
 }
 
+function fileListToMap(files) {
+  const map = new Map();
+  for (const file of files) {
+    map.set(file.relPath, file);
+  }
+  return map;
+}
+
+function makeFingerprint(file) {
+  return `${file.size}:${file.mtimeMs}`;
+}
+
+function normalizeRemoteRelPath(name) {
+  return String(name || '').replace(/\\/g, '/');
+}
+
+async function fetchAllRemoteFiles(server, token) {
+  const out = [];
+  const limit = 100;
+  let offset = 0;
+
+  while (true) {
+    const data = await httpJson(`${server}/api/files?limit=${limit}&offset=${offset}&sort=created_at&order=asc`, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    const rows = Array.isArray(data.files) ? data.files : [];
+    for (const row of rows) {
+      out.push({
+        id: row.id,
+        relPath: normalizeRemoteRelPath(row.original_name),
+        size: Number(row.file_size || 0)
+      });
+    }
+    if (!data.pagination?.hasMore) break;
+    offset += limit;
+  }
+
+  return out;
+}
+
+async function downloadRemoteFile(server, token, remoteFile, destPath) {
+  const res = await fetch(`${server}/api/files/${remoteFile.id}/download`, {
+    method: 'GET',
+    headers: { Authorization: `Bearer ${token}` }
+  });
+
+  if (!res.ok) {
+    let detail = `HTTP ${res.status}`;
+    try {
+      const data = await res.json();
+      detail = data.message || data.error || detail;
+    } catch {
+      // ignore JSON parse failures
+    }
+    throw new Error(detail);
+  }
+
+  if (!res.body) {
+    throw new Error('Reponse de telechargement vide');
+  }
+
+  await fsp.mkdir(path.dirname(destPath), { recursive: true });
+  const tempPath = `${destPath}.part`;
+  const writable = fs.createWriteStream(tempPath);
+  await pipeline(Readable.fromWeb(res.body), writable);
+  await fsp.rename(tempPath, destPath);
+}
+
+async function pullMissingRemoteFiles(server, token, rootDir, state, localFiles, remoteFiles, dryRun) {
+  const localMap = fileListToMap(localFiles);
+  const missingRemote = remoteFiles.filter((rf) => !localMap.has(rf.relPath));
+
+  if (missingRemote.length === 0) return { downloaded: 0, errors: 0 };
+
+  console.log(`A telecharger: ${missingRemote.length}`);
+  if (dryRun) {
+    for (const rf of missingRemote.slice(0, 50)) console.log(`- ${rf.relPath} (remote)`); // eslint-disable-line no-console
+    if (missingRemote.length > 50) console.log(`... +${missingRemote.length - 50} autres`);
+    return { downloaded: 0, errors: 0 };
+  }
+
+  let downloaded = 0;
+  let errors = 0;
+  for (let i = 0; i < missingRemote.length; i += 1) {
+    const rf = missingRemote[i];
+    const label = `[DOWN ${i + 1}/${missingRemote.length}]`;
+    try {
+      const absPath = path.join(rootDir, ...rf.relPath.split('/'));
+      console.log(`${label} GET ${rf.relPath} (${formatBytes(rf.size)})`);
+      await downloadRemoteFile(server, token, rf, absPath);
+      const st = await fsp.stat(absPath);
+      state.files[rf.relPath] = {
+        size: st.size,
+        mtimeMs: Math.round(st.mtimeMs),
+        uploadedAt: new Date().toISOString(),
+        remoteId: rf.id
+      };
+      downloaded += 1;
+      console.log(`${label} OK ${rf.relPath}`);
+    } catch (error) {
+      errors += 1;
+      console.error(`${label} FAIL ${rf.relPath} -> ${error.message}`);
+    }
+  }
+
+  return { downloaded, errors };
+}
+
+function seedStateFromRemote(state, localFiles, remoteFiles) {
+  const remoteByPath = new Map(remoteFiles.map((rf) => [rf.relPath, rf]));
+  for (const lf of localFiles) {
+    if (state.files[lf.relPath]) continue;
+    const remote = remoteByPath.get(lf.relPath);
+    if (!remote) continue;
+    if (Number(remote.size) !== Number(lf.size)) continue;
+    state.files[lf.relPath] = {
+      size: lf.size,
+      mtimeMs: lf.mtimeMs,
+      uploadedAt: new Date().toISOString(),
+      remoteId: remote.id
+    };
+  }
+}
+
+async function deleteRemoteFile(server, token, remoteId) {
+  return httpJson(`${server}/api/files/${remoteId}`, {
+    method: 'DELETE',
+    headers: { Authorization: `Bearer ${token}` }
+  });
+}
+
+async function renameRemoteFile(server, token, remoteId, newName) {
+  return httpJson(`${server}/api/files/${remoteId}/rename`, {
+    method: 'PATCH',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ newName })
+  });
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function mirrorRealtime(server, token, rootDir, state, intervalMs) {
+  console.log(`Mode temps reel actif (${intervalMs} ms). Ctrl+C pour quitter.`);
+
+  let stopped = false;
+  const onStop = () => { stopped = true; };
+  process.on('SIGINT', onStop);
+  process.on('SIGTERM', onStop);
+
+  let previousFiles = await listFilesRecursive(rootDir);
+  let previousMap = fileListToMap(previousFiles);
+
+  while (!stopped) {
+    await sleep(intervalMs);
+    if (stopped) break;
+
+    let currentFiles;
+    try {
+      currentFiles = await listFilesRecursive(rootDir);
+    } catch (error) {
+      console.error(`Watcher error: ${error.message}`);
+      continue;
+    }
+
+    const currentMap = fileListToMap(currentFiles);
+    const prevKeys = new Set(previousMap.keys());
+    const currKeys = new Set(currentMap.keys());
+    const removed = [...prevKeys].filter((k) => !currKeys.has(k)).map((k) => previousMap.get(k));
+    const added = [...currKeys].filter((k) => !prevKeys.has(k)).map((k) => currentMap.get(k));
+    const changed = [...currKeys]
+      .filter((k) => prevKeys.has(k))
+      .map((k) => ({ prev: previousMap.get(k), cur: currentMap.get(k) }))
+      .filter((p) => p.prev.size !== p.cur.size || p.prev.mtimeMs !== p.cur.mtimeMs)
+      .map((p) => p.cur);
+
+    // Detecter les renames simples (meme taille + mtime) pour appeler PATCH rename.
+    const addedByFinger = new Map();
+    for (const a of added) {
+      const key = makeFingerprint(a);
+      if (!addedByFinger.has(key)) addedByFinger.set(key, []);
+      addedByFinger.get(key).push(a);
+    }
+
+    const renamedPairs = [];
+    const trulyRemoved = [];
+    for (const r of removed) {
+      const matches = addedByFinger.get(makeFingerprint(r)) || [];
+      const remoteId = state.files[r.relPath]?.remoteId || null;
+      if (remoteId && matches.length > 0) {
+        const to = matches.shift();
+        renamedPairs.push({ from: r, to, remoteId });
+      } else {
+        trulyRemoved.push(r);
+      }
+    }
+    const renamedTargets = new Set(renamedPairs.map((p) => p.to.relPath));
+    const trulyAdded = added.filter((a) => !renamedTargets.has(a.relPath));
+
+    for (const pair of renamedPairs) {
+      try {
+        await renameRemoteFile(server, token, pair.remoteId, pair.to.relPath);
+        delete state.files[pair.from.relPath];
+        state.files[pair.to.relPath] = {
+          size: pair.to.size,
+          mtimeMs: pair.to.mtimeMs,
+          uploadedAt: new Date().toISOString(),
+          remoteId: pair.remoteId
+        };
+        console.log(`[WATCH] RENAME ${pair.from.relPath} -> ${pair.to.relPath}`);
+      } catch (error) {
+        console.error(`[WATCH] RENAME FAIL ${pair.from.relPath} -> ${pair.to.relPath}: ${error.message}`);
+      }
+    }
+
+    for (const file of trulyRemoved) {
+      const remoteId = state.files[file.relPath]?.remoteId || null;
+      if (!remoteId) {
+        delete state.files[file.relPath];
+        continue;
+      }
+      try {
+        await deleteRemoteFile(server, token, remoteId);
+        delete state.files[file.relPath];
+        console.log(`[WATCH] DELETE ${file.relPath}`);
+      } catch (error) {
+        console.error(`[WATCH] DELETE FAIL ${file.relPath}: ${error.message}`);
+      }
+    }
+
+    const uploads = [...trulyAdded, ...changed];
+    for (const file of uploads) {
+      try {
+        const result = await uploadOneFile(server, token, file);
+        state.files[file.relPath] = {
+          size: file.size,
+          mtimeMs: file.mtimeMs,
+          uploadedAt: new Date().toISOString(),
+          remoteId: result?.file?.id || state.files[file.relPath]?.remoteId || null
+        };
+        console.log(`[WATCH] UPLOAD ${file.relPath} (${formatBytes(file.size)})`);
+      } catch (error) {
+        console.error(`[WATCH] UPLOAD FAIL ${file.relPath}: ${error.message}`);
+      }
+    }
+
+    await writeState(rootDir, state);
+    previousFiles = currentFiles;
+    previousMap = currentMap;
+  }
+
+  process.off('SIGINT', onStop);
+  process.off('SIGTERM', onStop);
+}
+
 async function syncFolder(positionals, flags) {
   const target = positionals[0];
   if (!target) {
-    throw new Error('Usage: shard sync <folder> [--server <url>] [--dry-run] [--force]');
+    throw new Error('Usage: shard sync <folder> [--server <url>] [--dry-run] [--force] [--once] [--interval-ms <n>]');
   }
 
   const rootDir = path.resolve(process.cwd(), target);
@@ -300,10 +575,18 @@ async function syncFolder(positionals, flags) {
     headers: { Authorization: `Bearer ${token}` }
   });
 
-  const files = await listFilesRecursive(rootDir);
   const state = await readState(rootDir);
   const force = Boolean(flags.force);
   const dryRun = Boolean(flags['dry-run']);
+  const once = Boolean(flags.once);
+  const intervalMs = Math.max(parseInt(flags['interval-ms'] || '2000', 10) || 2000, 500);
+
+  const remoteFiles = await fetchAllRemoteFiles(server, token);
+  const initialLocalFiles = await listFilesRecursive(rootDir);
+  await pullMissingRemoteFiles(server, token, rootDir, state, initialLocalFiles, remoteFiles, dryRun);
+
+  const files = await listFilesRecursive(rootDir);
+  seedStateFromRemote(state, files, remoteFiles);
 
   const changed = files.filter((f) => {
     if (force) return true;
@@ -316,6 +599,7 @@ async function syncFolder(positionals, flags) {
   console.log(`Server: ${server}`);
   console.log(`Dossier: ${rootDir}`);
   console.log(`Total: ${files.length} fichier(s)`);
+  console.log(`Distants: ${remoteFiles.length}`);
   console.log(`A uploader: ${changed.length}`);
   console.log(`Inchanges: ${unchanged}`);
 
@@ -332,7 +616,10 @@ async function syncFolder(positionals, flags) {
     const file = changed[i];
     const label = `[${i + 1}/${changed.length}]`;
     try {
+      const startedAt = Date.now();
+      console.log(`${label} UPLOAD ${file.relPath} (${formatBytes(file.size)})`);
       const result = await uploadOneFile(server, token, file);
+      const tookSeconds = ((Date.now() - startedAt) / 1000).toFixed(1);
       success += 1;
       state.files[file.relPath] = {
         size: file.size,
@@ -340,7 +627,7 @@ async function syncFolder(positionals, flags) {
         uploadedAt: new Date().toISOString(),
         remoteId: result?.file?.id || null
       };
-      console.log(`${label} OK ${file.relPath}`);
+      console.log(`${label} OK ${file.relPath} (${tookSeconds}s)`);
     } catch (error) {
       failed += 1;
       console.error(`${label} FAIL ${file.relPath} -> ${error.message}`);
@@ -355,6 +642,9 @@ async function syncFolder(positionals, flags) {
 
   console.log(`Termine. Uploades: ${success}, erreurs: ${failed}`);
   if (failed > 0) process.exitCode = 2;
+  if (!once && !dryRun) {
+    await mirrorRealtime(server, token, rootDir, state, intervalMs);
+  }
 }
 
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iksdev/shard-cli",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "CLI pour synchroniser un dossier local avec Shard",
   "bin": {
     "shard": "bin/shard.js"