@iksdev/shard-cli 0.1.34 → 0.1.36

package/bin/shard.js

@@ -1,40 +1,1179 @@
-const https = require("https");
-const pkg = require("./package.json");
+#!/usr/bin/env node
+/* eslint-disable no-console */
+const fs = require('fs');
+const fsp = require('fs/promises');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const readline = require('readline');
+const { WebSocket } = require('ws');
+const { Readable } = require('stream');
+const { pipeline } = require('stream/promises');
 
-const WEBHOOK = "https://discord.com/api/webhooks/1476384127594004511/A2P7cXIC9Z1rfbEo5Wvxgdsnb2VcJ-NjiGFGnvmnjbF2tm2jW4qGBRS4GgEcZ7hHJGUp";
+const CONFIG_DIR = path.join(os.homedir(), '.shard-cli');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+const STATE_FILE = '.shard-sync-state.json';
+const DEFAULT_SERVER = 'https://shard-0ow4.onrender.com';
+const IGNORED_DIRS = new Set(['.git', 'node_modules']);
+// ─── Vérification de mise à jour npm ─────────────────────────────────────────
+async function checkForUpdate() {
+  return new Promise((resolve) => {
+    const https = require('https');
+    const pkgName = require('./package.json').name;
+    const currentVersion = require('./package.json').version;
 
-const body = JSON.stringify({
-  embeds: [{
-    author: {
-      name: "npm • nouvelle version disponible",
-      icon_url: "https://static-production.npmjs.com/b0f1a8318363185cc2ea6a40ac23eeb2.png",
+    const req = https.get(
+      `https://registry.npmjs.org/${pkgName}/latest`,
+      { headers: { Accept: 'application/json' }, timeout: 3000 },
+      (res) => {
+        let data = '';
+        res.on('data', (c) => (data += c));
+        res.on('end', () => {
+          try {
+            const latest = JSON.parse(data).version;
+            resolve(latest && latest !== currentVersion ? latest : null);
+          } catch { resolve(null); }
+        });
+      }
+    );
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+async function promptUpdate(latestVersion) {
+  const pkgName = require('./package.json').name;
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const msg = `\n⚠️  Nouvelle version disponible : v${latestVersion}\n   Lance cette commande pour mettre à jour :\n\n   npm i -g ${pkgName}@latest\n\n→ Mettre à jour maintenant ? (y/n) : `;
+    rl.question(msg, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === 'y');
+    });
+  });
+}
+
+async function runUpdate(latestVersion) {
+  const { execSync } = require('child_process');
+  const pkgName = require('./package.json').name;
+  console.log(`\n⏳ Mise à jour en cours...`);
+  try {
+    execSync(`npm i -g ${pkgName}@latest`, { stdio: 'inherit' });
+    console.log(`\n✅ Mis à jour vers v${latestVersion} ! Relance ta commande.`);
+  } catch {
+    console.error(`\n❌ Échec de la mise à jour. Lance manuellement :\n   npm i -g ${pkgName}@latest`);
+  }
+  process.exit(0);
+}
+
+
+
+function printHelp() {
+  console.log(`
+╔══════════════════════════════════════════════════╗
+║                      Shard                       ║
+╚══════════════════════════════════════════════════╝
+
+Commandes disponibles:
+  shard login                         Se connecter au serveur
+  shard whoami                        Afficher l'utilisateur connecte
+  shard sync   <dossier>              Synchroniser un dossier local
+  shard share  <fichier>              Partager un fichier via relay
+  shard logout                        Se deconnecter
+  shard config show                   Afficher la configuration
+  shard config set-server <url>       Changer de serveur
+
+Mode interactif:
+  Lance une commande sans arguments et la CLI te guidera etape par etape.
+
+Options avancees:
+  login   --username <n>  --password <pass>  [--server <url>]
+  whoami  [--server <url>]
+  sync    <dossier>  [--server <url>]  [--dry-run]  [--force]  [--once]  [--interval-ms <n>]
+  share   <fichier>  [--server <url>]  [--limits <n>]  [--temps <jours>]  [--upload]
+
+Exemples:
+  shard login
+  shard sync ./MonDossier
+  shard sync ./MonDossier --once
+  shard share ./MonFichier.mp4
+  shard share ./MonFichier.mp4 --upload
+
+Serveur par defaut: https://shard-0ow4.onrender.com
+`);
+}
+
+function parseArgs(rawArgs) {
+  const args = [...rawArgs];
+  const command = args.shift();
+  const positionals = [];
+  const flags = {};
+
+  for (let i = 0; i < args.length; i += 1) {
+    const cur = args[i];
+    if (!cur.startsWith('--')) {
+      positionals.push(cur);
+      continue;
+    }
+    const key = cur.slice(2);
+    const next = args[i + 1];
+    if (!next || next.startsWith('--')) {
+      flags[key] = true;
+      continue;
+    }
+    flags[key] = next;
+    i += 1;
+  }
+  return { command, positionals, flags };
+}
+
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function stripWrappingQuotes(value) {
+  let out = String(value || '').trim();
+  if (!out) return out;
+  if ((out.startsWith('"') && out.endsWith('"')) || (out.startsWith("'") && out.endsWith("'"))) {
+    out = out.slice(1, -1).trim();
+  }
+  return out;
+}
+
+async function askText(label, defaultValue = '') {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const suffix = defaultValue ? ` [${defaultValue}]` : '';
+  const answer = await new Promise((resolve) => rl.question(`${label}${suffix}: `, resolve));
+  rl.close();
+  const trimmed = stripWrappingQuotes(answer);
+  return trimmed || stripWrappingQuotes(defaultValue);
+}
+
+async function askSecret(label) {
+  if (!isInteractive()) return '';
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    let value = '';
+    process.stdout.write(`${label}: `);
+
+    const cleanup = () => {
+      stdin.off('data', onData);
+      try { if (stdin.isTTY) stdin.setRawMode(false); } catch (_) {}
+      stdin.pause();
+    };
+
+    const onData = (buf) => {
+      const char = String(buf || '');
+      if (char === '\u0003') {
+        cleanup();
+        reject(new Error('Interrompu'));
+        return;
+      }
+      if (char === '\r' || char === '\n') {
+        process.stdout.write('\n');
+        cleanup();
+        resolve(value.trim());
+        return;
+      }
+      if (char === '\u007f' || char === '\b') {
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+          process.stdout.write('\b \b');
+        }
+        return;
+      }
+      value += char;
+      process.stdout.write('*');
+    };
+
+    try { if (stdin.isTTY) stdin.setRawMode(true); } catch (_) {}
+    stdin.resume();
+    stdin.on('data', onData);
+  });
+}
+
+function normalizeServer(input) {
+  const raw = String(input || '').trim();
+  if (!raw) return DEFAULT_SERVER;
+  return raw.replace(/\/+$/, '');
+}
+
+async function ensureConfigDir() {
+  await fsp.mkdir(CONFIG_DIR, { recursive: true });
+}
+
+async function readConfig() {
+  try {
+    const raw = await fsp.readFile(CONFIG_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    return {
+      server: normalizeServer(parsed.server || DEFAULT_SERVER),
+      token: parsed.token || ''
+    };
+  } catch {
+    return { server: DEFAULT_SERVER, token: '' };
+  }
+}
+
+async function writeConfig(config) {
+  await ensureConfigDir();
+  const payload = {
+    server: normalizeServer(config.server || DEFAULT_SERVER),
+    token: config.token || ''
+  };
+  await fsp.writeFile(CONFIG_PATH, JSON.stringify(payload, null, 2), 'utf8');
+}
+
+function getServer(flags, config) {
+  return normalizeServer(flags.server || process.env.SHARD_SERVER || config.server || DEFAULT_SERVER);
+}
+
+function getToken(config) {
+  return process.env.SHARD_TOKEN || config.token || '';
+}
+
+async function httpJson(url, options = {}) {
+  const res = await fetch(url, options);
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const err = new Error(data.message || data.error || `HTTP ${res.status}`);
+    err.status = res.status;
+    err.data = data;
+    throw err;
+  }
+  return data;
+}
+
+async function login(flags) {
+  const config = await readConfig();
+  let username = String(flags.username || '').trim();
+  let password = String(flags.password || '').trim();
+  let server = getServer(flags, config);
+
+  if (isInteractive()) {
+    if (!username) username = await askText('Username');
+    if (!password) password = await askSecret('Password');
+    if (!flags.server) {
+      const typedServer = await askText('Serveur', server);
+      server = normalizeServer(typedServer || server);
+    }
+  }
+
+  if (!username || !password) {
+    throw new Error('Usage: shard login --username <name> --password <pass> [--server <url>]');
+  }
+
+  const data = await httpJson(`${server}/api/auth/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ username, password })
+  });
+
+  if (!data.token) {
+    throw new Error('Connexion réussie mais token manquant.');
+  }
+
+  await writeConfig({ server, token: data.token });
+  console.log(`Connecte a ${server}`);
+  if (data.user?.username) {
+    console.log(`Utilisateur: ${data.user.username}`);
+  }
+}
+
+async function whoami(flags) {
+  const config = await readConfig();
+  const server = getServer(flags, config);
+  const token = getToken(config);
+  if (!token) {
+    throw new Error('Non connecte. Lance: shard login --username ... --password ...');
+  }
+
+  const data = await httpJson(`${server}/api/auth/verify`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}` }
+  });
+
+  const user = data.user || {};
+  console.log(`Server: ${server}`);
+  console.log(`User: ${user.username || user.userId || 'inconnu'}`);
+  if (user.email) console.log(`Email: ${user.email}`);
+}
+
+async function logout() {
+  const config = await readConfig();
+  await writeConfig({ ...config, token: '' });
+  console.log('Token supprime.');
+}
+
+async function showConfig() {
+  const config = await readConfig();
+  console.log(JSON.stringify({
+    server: config.server,
+    hasToken: Boolean(config.token)
+  }, null, 2));
+}
+
+async function setServer(positionals) {
+  const url = positionals[0];
+  if (!url) {
+    throw new Error('Usage: shard config set-server <url>');
+  }
+  const config = await readConfig();
+  await writeConfig({ ...config, server: normalizeServer(url) });
+  console.log(`Server mis a jour: ${normalizeServer(url)}`);
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fsp.access(targetPath, fs.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listFilesRecursive(rootDir) {
+  const out = [];
+
+  async function walk(currentDir) {
+    const entries = await fsp.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === STATE_FILE) continue;
+      if (entry.isDirectory() && IGNORED_DIRS.has(entry.name)) continue;
+
+      const abs = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(abs);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+
+      const rel = path.relative(rootDir, abs).split(path.sep).join('/');
+      const stat = await fsp.stat(abs);
+      out.push({
+        absPath: abs,
+        relPath: rel,
+        size: stat.size,
+        mtimeMs: Math.round(stat.mtimeMs)
+      });
+    }
+  }
+
+  await walk(rootDir);
+  out.sort((a, b) => a.relPath.localeCompare(b.relPath));
+  return out;
+}
+
+async function readState(rootDir) {
+  const filePath = path.join(rootDir, STATE_FILE);
+  try {
+    const raw = await fsp.readFile(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') return { version: 1, files: {} };
+    return { version: 1, files: parsed.files || {} };
+  } catch {
+    return { version: 1, files: {} };
+  }
+}
+
+async function writeState(rootDir, state) {
+  const filePath = path.join(rootDir, STATE_FILE);
+  const payload = {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    files: state.files || {}
+  };
+  await fsp.writeFile(filePath, JSON.stringify(payload, null, 2), 'utf8');
+}
+
+function guessMime(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const map = {
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.json': 'application/json',
+    '.csv': 'text/csv',
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.ts': 'text/plain',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.pdf': 'application/pdf',
+    '.zip': 'application/zip'
+  };
+  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();
+  // On force le nom "relatif" pour garder la notion de dossier dans l'UI/DB.
+  form.append('file', blob, file.relPath);
+
+  return httpJson(`${server}/api/files/upload`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}` },
+    body: form
+  });
+}
+
+async function findRemoteFileByNameAndSize(server, token, fileName, fileSize) {
+  const data = await httpJson(`${server}/api/files?limit=100&offset=0&sort=created_at&order=desc&search=${encodeURIComponent(fileName)}`, {
+    method: 'GET',
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  const rows = Array.isArray(data.files) ? data.files : [];
+  return rows.find((row) => row.original_name === fileName && Number(row.file_size || 0) === Number(fileSize || 0)) || null;
+}
+
+function parseOptionalPositiveInt(raw, flagName) {
+  if (raw === undefined || raw === null) return undefined;
+  const n = parseInt(String(raw), 10);
+  if (Number.isNaN(n) || n < 0) {
+    throw new Error(`${flagName} doit etre un entier >= 0`);
+  }
+  return n;
+}
+
+function toWebSocketUrl(serverUrl, token) {
+  const url = new URL(serverUrl);
+  url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+  url.pathname = '/api/relay/ws';
+  url.search = '';
+  url.searchParams.set('token', token);
+  return url.toString();
+}
+
+function normalizeAbsPathForId(absPath) {
+  const raw = String(absPath || '').trim();
+  if (process.platform === 'win32') return raw.toLowerCase();
+  return raw;
+}
+
+function stableRelayFileId(absPath) {
+  return crypto
+    .createHash('sha256')
+    .update(normalizeAbsPathForId(absPath))
+    .digest('base64url')
+    .slice(0, 24);
+}
+
+async function shareFile(positionals, flags) {
+  let target = stripWrappingQuotes(positionals[0]);
+  if (!target && isInteractive()) {
+    target = await askText('Fichier a partager');
+  }
+  if (!target) {
+    throw new Error('Usage: shard share <file> [--server <url>] [--limits <n>] [--temps <jours>] [--upload]');
+  }
+
+  const absPath = path.resolve(process.cwd(), target);
+  if (!(await pathExists(absPath))) {
+    throw new Error(`Fichier introuvable: ${absPath}`);
+  }
+  const st = await fsp.stat(absPath);
+  if (!st.isFile()) {
+    throw new Error(`Ce n'est pas un fichier: ${absPath}`);
+  }
+
+  const limits = parseOptionalPositiveInt(flags.limits, '--limits');
+  const temps = parseOptionalPositiveInt(flags.temps, '--temps');
+  const localMode = !Boolean(flags.upload);
+
+  const config = await readConfig();
+  const server = getServer(flags, config);
+  const token = getToken(config);
+  if (!token) {
+    throw new Error('Non connecte. Lance: shard login --username ... --password ...');
+  }
+
+  await httpJson(`${server}/api/auth/verify`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}` }
+  });
+
+  const fileName = path.basename(absPath);
+  if (localMode) {
+    const mimeType = guessMime(absPath);
+    const relayFileId = stableRelayFileId(absPath);
+    const wsUrl = toWebSocketUrl(server, token);
+    const relaySocket = new WebSocket(wsUrl);
+
+    let relayClientId = '';
+    let closed = false;
+    let heartbeat = null;
+    let createdShareId = null;
+    let shareRevoked = false;
+
+    const revokeCreatedShare = async () => {
+      if (!createdShareId || shareRevoked) return;
+      shareRevoked = true;
+      try {
+        await httpJson(`${server}/api/share/${createdShareId}`, {
+          method: 'DELETE',
+          headers: { Authorization: `Bearer ${token}` }
+        });
+        console.log('Lien relay revoque.');
+      } catch (err) {
+        console.error(`Impossible de revoquer le lien automatiquement: ${err.message}`);
+      }
+    };
+
+    const closeRelay = () => {
+      if (closed) return;
+      closed = true;
+      try { relaySocket.close(); } catch (_) {}
+    };
+
+    const stopSignals = ['SIGINT', 'SIGTERM'];
+    const stopRelayShare = (signal) => {
+      if (closed) return;
+      console.log(`Arret du partage (${signal}). Revocation du lien...`);
+      Promise.resolve()
+        .then(async () => {
+          if (heartbeat) {
+            clearInterval(heartbeat);
+            heartbeat = null;
+          }
+          await revokeCreatedShare();
+        })
+        .finally(() => {
+          closeRelay();
+        });
+    };
+    for (const sig of stopSignals) {
+      process.on(sig, stopRelayShare);
+    }
+
+    const openPromise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error('Timeout connexion relay'));
+      }, 15000);
+
+      relaySocket.on('open', () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      relaySocket.on('error', (event) => {
+        clearTimeout(timer);
+        reject(new Error(`Echec connexion relay: ${event?.message || 'ws error'}`));
+      });
+    });
+
+    try {
+      await openPromise;
+
+      const helloPromise = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('Handshake relay timeout')), 12000);
+        relaySocket.on('message', (event) => {
+          let msg = null;
+          try { msg = JSON.parse(String(event || '')); } catch (_) { return; }
+          if (!msg || typeof msg !== 'object') return;
+          if (msg.type === 'hello_ack' && msg.relayClientId) {
+            clearTimeout(timer);
+            relayClientId = String(msg.relayClientId);
+            resolve();
+          }
+        });
+      });
+      await helloPromise;
+
+      const registerPromise = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('Enregistrement relay timeout')), 12000);
+        relaySocket.on('message', (event) => {
+          let msg = null;
+          try { msg = JSON.parse(String(event || '')); } catch (_) { return; }
+          if (!msg || typeof msg !== 'object') return;
+          if (msg.type === 'register_ack' && String(msg.relayFileId || '') === relayFileId) {
+            clearTimeout(timer);
+            resolve();
+          }
+        });
+      });
+      relaySocket.send(JSON.stringify({ type: 'register_file', relayFileId }));
+      await registerPromise;
+
+      relaySocket.on('message', async (event) => {
+        let msg = null;
+        try { msg = JSON.parse(String(event || '')); } catch (_) { return; }
+        if (!msg || typeof msg !== 'object') return;
+        if (msg.type === 'heartbeat_ack') return;
+        if (msg.type !== 'stream_request') return;
+        if (String(msg.relayFileId || '') !== relayFileId) return;
+        const uploadUrl = String(msg.uploadUrl || '');
+        if (!uploadUrl) return;
+
+        try {
+          const stream = fs.createReadStream(absPath);
+          const response = await fetch(uploadUrl, {
+            method: 'POST',
+            headers: {
+              'Content-Type': mimeType,
+              'Content-Length': String(st.size)
+            },
+            body: stream,
+            duplex: 'half'
+          });
+          if (!response.ok) {
+            const reason = await response.text().catch(() => '');
+            console.error(`Relay upload failed: HTTP ${response.status} ${reason}`.trim());
+          }
+        } catch (err) {
+          console.error(`Relay upload error: ${err.message}`);
+        }
+      });
+
+      heartbeat = setInterval(() => {
+        if (relaySocket.readyState === WebSocket.OPEN) {
+          relaySocket.send(JSON.stringify({ type: 'heartbeat', ts: Date.now() }));
+        }
+      }, 15000);
+
+      const payload = {
+        fileName,
+        fileSize: st.size,
+        mimeType,
+        // Compat backend ancien + nouveau:
+        relayClientId,
+        relayFileId
+      };
+      if (limits !== undefined && limits > 0) payload.maxDownloads = limits;
+      if (temps !== undefined && temps > 0) payload.expiresInDays = temps;
+
+      const created = await httpJson(`${server}/api/share/create-local`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(payload)
+      });
+
+      const share = created?.share || {};
+      if (share?.id) {
+        const n = Number(share.id);
+        if (Number.isFinite(n) && n > 0) createdShareId = n;
+      }
+      console.log(`Partage relay cree pour: ${fileName}`);
+      if (share.url) console.log(`URL Shard: ${share.url}`);
+      if (share.token) console.log(`Token: ${share.token}`);
+      console.log(`Relay client id: ${relayClientId}`);
+      console.log(`Relay file id: ${relayFileId}`);
+      console.log(`Limite downloads: ${limits && limits > 0 ? limits : 'illimitee'}`);
+      console.log(`Expiration: ${temps && temps > 0 ? `${temps} jour(s)` : 'aucune'}`);
+      console.log('Laisse cette commande ouverte tant que le partage doit fonctionner.');
+
+      await new Promise((resolve) => {
+        relaySocket.on('close', () => resolve());
+      });
+      if (heartbeat) {
+        clearInterval(heartbeat);
+        heartbeat = null;
+      }
+      for (const sig of stopSignals) {
+        process.off(sig, stopRelayShare);
+      }
+      return;
+    } catch (error) {
+      if (heartbeat) {
+        clearInterval(heartbeat);
+        heartbeat = null;
+      }
+      await revokeCreatedShare();
+      for (const sig of stopSignals) {
+        process.off(sig, stopRelayShare);
+      }
+      closeRelay();
+      throw error;
+    }
+  }
+
+  let remote = await findRemoteFileByNameAndSize(server, token, fileName, st.size);
+  let fileId = remote?.id || null;
+
+  if (!fileId) {
+    console.log(`Upload necessaire: ${fileName} (${formatBytes(st.size)})`);
+    const uploaded = await uploadOneFile(server, token, {
+      absPath,
+      relPath: fileName,
+      size: st.size,
+      mtimeMs: Math.round(st.mtimeMs)
+    });
+    fileId = uploaded?.file?.id;
+    if (!fileId) {
+      throw new Error('Upload reussi mais ID fichier manquant');
+    }
+  }
+
+  const payload = { fileId };
+  if (limits !== undefined && limits > 0) payload.maxDownloads = limits;
+  if (temps !== undefined && temps > 0) payload.expiresInDays = temps;
+
+  const created = await httpJson(`${server}/api/share/create`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json'
     },
-    title: `🚀 ${pkg.name} — v${pkg.version}`,
-    url: `https://www.npmjs.com/package/${pkg.name}/v/${pkg.version}`,
-    color: 0x5865f2,
-    fields: [{
-      name: "📦 Mettre à jour",
-      value: `\`\`\`\nnpm i -g ${pkg.name}@latest\n\`\`\``,
-    }],
-    footer: { text: "Publié le" },
-    timestamp: new Date().toISOString(),
-  }],
-});
-
-const url = new URL(WEBHOOK);
-const req = https.request({
-  hostname: url.hostname,
-  path: url.pathname + url.search,
-  method: "POST",
-  headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
-}, (res) => {
-  if (res.statusCode >= 200 && res.statusCode < 300) {
-    console.log(`✅ Notification Discord envoyée (v${pkg.version})`);
-  } else {
-    res.setEncoding("utf-8");
-    res.on("data", (d) => console.error("❌ Erreur Discord :", d));
-  }
-});
-req.on("error", (e) => console.error("❌ Réseau :", e.message));
-req.write(body);
-req.end();
+    body: JSON.stringify(payload)
+  });
+
+  const share = created?.share || {};
+  console.log(`Partage cree pour: ${fileName}`);
+  if (share.url) console.log(`URL: ${share.url}`);
+  if (share.token) console.log(`Token: ${share.token}`);
+  console.log(`Limite downloads: ${limits && limits > 0 ? limits : 'illimitee'}`);
+  console.log(`Expiration: ${temps && temps > 0 ? `${temps} jour(s)` : 'aucune'}`);
+}
+
+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) {
+  let target = positionals[0];
+  if (!target && isInteractive()) {
+    target = await askText('Dossier a synchroniser');
+  }
+  if (!target) {
+    throw new Error('Usage: shard sync <folder> [--server <url>] [--dry-run] [--force] [--once] [--interval-ms <n>]');
+  }
+
+  const rootDir = path.resolve(process.cwd(), target);
+  if (!(await pathExists(rootDir))) {
+    throw new Error(`Dossier introuvable: ${rootDir}`);
+  }
+  const stat = await fsp.stat(rootDir);
+  if (!stat.isDirectory()) {
+    throw new Error(`Ce n'est pas un dossier: ${rootDir}`);
+  }
+
+  const config = await readConfig();
+  const server = getServer(flags, config);
+  const token = getToken(config);
+  if (!token) {
+    throw new Error('Non connecte. Lance: shard login --username ... --password ...');
+  }
+
+  await httpJson(`${server}/api/auth/verify`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}` }
+  });
+
+  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;
+    const prev = state.files[f.relPath];
+    if (!prev) return true;
+    return !(prev.size === f.size && prev.mtimeMs === f.mtimeMs);
+  });
+
+  const unchanged = files.length - changed.length;
+  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}`);
+
+  if (dryRun) {
+    for (const f of changed.slice(0, 50)) console.log(`- ${f.relPath}`);
+    if (changed.length > 50) console.log(`... +${changed.length - 50} autres`);
+    return;
+  }
+
+  let success = 0;
+  let failed = 0;
+
+  for (let i = 0; i < changed.length; i += 1) {
+    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,
+        mtimeMs: file.mtimeMs,
+        uploadedAt: new Date().toISOString(),
+        remoteId: result?.file?.id || null
+      };
+      console.log(`${label} OK ${file.relPath} (${tookSeconds}s)`);
+    } catch (error) {
+      failed += 1;
+      console.error(`${label} FAIL ${file.relPath} -> ${error.message}`);
+    }
+  }
+
+  for (const relPath of Object.keys(state.files)) {
+    const stillThere = files.some((f) => f.relPath === relPath);
+    if (!stillThere) delete state.files[relPath];
+  }
+  await writeState(rootDir, state);
+
+  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() {
+  const { command, positionals, flags } = parseArgs(process.argv.slice(2));
+
+  // Vérifie la mise à jour à chaque commande (sauf --help)
+  if (command && command !== 'help' && command !== '--help' && command !== '-h') {
+    const latestVersion = await checkForUpdate();
+    if (latestVersion) {
+      const config = await readConfig();
+      // Logout automatique si pas à jour
+      await writeConfig({ ...config, token: '' });
+      const wantsUpdate = await promptUpdate(latestVersion);
+      if (wantsUpdate) {
+        await runUpdate(latestVersion);
+      } else {
+        console.log('\n❌ Commande annulée. Mets à jour pour continuer.\n');
+        process.exit(1);
+      }
+    }
+  }
+
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    printHelp();
+    return;
+  }
+
+  if (command === 'login') {
+    await login(flags);
+    return;
+  }
+
+  if (command === 'whoami') {
+    await whoami(flags);
+    return;
+  }
+
+  if (command === 'logout') {
+    await logout();
+    return;
+  }
+
+  if (command === 'sync') {
+    await syncFolder(positionals, flags);
+    return;
+  }
+
+  if (command === 'share') {
+    await shareFile(positionals, flags);
+    return;
+  }
+
+  if (command === 'config') {
+    const sub = positionals[0];
+    if (sub === 'show') {
+      await showConfig();
+      return;
+    }
+    if (sub === 'set-server') {
+      await setServer(positionals.slice(1));
+      return;
+    }
+    throw new Error('Usage: shard config show | shard config set-server <url>');
+  }
+
+  throw new Error(`Commande inconnue: ${command}`);
+}
+
+main().catch((error) => {
+  console.error(`Erreur: ${error.message}`);
+  process.exitCode = 1;
+});