@iksdev/shard-cli 0.1.26 → 0.1.28

package/bin/shard.js

@@ -1,14 +1,14 @@
 #!/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 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 CONFIG_DIR = path.join(os.homedir(), '.shard-cli');
 const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
@@ -16,37 +16,42 @@ const STATE_FILE = '.shard-sync-state.json';
 const DEFAULT_SERVER = 'https://shard-0ow4.onrender.com';
 const IGNORED_DIRS = new Set(['.git', 'node_modules']);
 
-function printHelp() {
-  console.log(`Shard CLI
-
-Commandes:
-  shard login
-  shard whoami
-  shard sync
-  shard share
-  shard logout
-  shard config show
-  shard config set-server <url>
-
-Mode interactif:
-  La CLI pose les questions (fichier, dossier, serveur, identifiants) si tu ne passes pas d'arguments.
-
-Options avancees (optionnelles):
-  login: --username <name> --password <pass> --server <url>
-  whoami: --server <url>
-  sync: <folder> --server <url> --dry-run --force --once --interval-ms <n>
-  share: <file> --server <url> --limits <n> --temps <jours> --upload
-
-Examples:
-  shard login
-  shard sync
-  shard share
-  shard sync ./MonDossier --once
-  shard share ./MonFichier.mp4 --upload
-`);
-}
-
-function parseArgs(rawArgs) {
+function printHelp() {
+  console.log(`
+╔══════════════════════════════════════════════════╗
+║                 Shard CLI  🚀                    ║
+╚══════════════════════════════════════════════════╝
+
+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 = [];
@@ -67,76 +72,76 @@ function parseArgs(rawArgs) {
     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);
-  });
-}
+  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();
@@ -190,24 +195,24 @@ async function httpJson(url, options = {}) {
   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>]');
-  }
+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',
@@ -388,46 +393,46 @@ async function findRemoteFileByNameAndSize(server, token, fileName, fileSize) {
   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]');
-  }
+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))) {
@@ -438,9 +443,9 @@ async function shareFile(positionals, flags) {
     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 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);
@@ -449,208 +454,208 @@ async function shareFile(positionals, flags) {
     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);
+  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) {
@@ -948,14 +953,14 @@ async function mirrorRealtime(server, token, rootDir, state, intervalMs) {
   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>]');
-  }
+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))) {
@@ -1102,4 +1107,4 @@ async function main() {
 main().catch((error) => {
   console.error(`Erreur: ${error.message}`);
   process.exitCode = 1;
-});
+});

package/notify-discord.js

@@ -1,63 +1,133 @@
 const https = require("https");
-const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+const os = require("os");
 const pkg = require("./package.json");
 
 const WEBHOOK = "https://discord.com/api/webhooks/1476384127594004511/A2P7cXIC9Z1rfbEo5Wvxgdsnb2VcJ-NjiGFGnvmnjbF2tm2jW4qGBRS4GgEcZ7hHJGUp";
 const GEMINI_KEY = "AIzaSyBXSnhnYSI6A1cgYAQzmE7pWmmOZi3H334"; // https://aistudio.google.com/apikey
 
-// ─── Git helpers ──────────────────────────────────────────────────────────────
-function getLastTag() {
-  try {
-    return execSync("git describe --tags --abbrev=0 HEAD^", { encoding: "utf-8" }).trim();
-  } catch {
-    return null;
-  }
+// ─── Récupère la version précédente sur npm ───────────────────────────────────
+async function getPreviousVersion() {
+  return new Promise((resolve) => {
+    https.get(
+      `https://registry.npmjs.org/${pkg.name}`,
+      { headers: { Accept: "application/json" } },
+      (res) => {
+        let data = "";
+        res.on("data", (c) => (data += c));
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            const versions = Object.keys(json.versions || {});
+            resolve(versions[versions.length - 2] || null);
+          } catch { resolve(null); }
+        });
+      }
+    ).on("error", () => resolve(null));
+  });
 }
 
-function getCommits(lastTag) {
-  try {
-    const ref = lastTag ? `${lastTag}..HEAD` : "HEAD~10..HEAD";
-    return execSync(`git log ${ref} --pretty=format:"%s" --no-merges`, { encoding: "utf-8" }).trim();
-  } catch {
-    return null;
+// ─── Télécharge le tarball npm en mémoire ─────────────────────────────────────
+async function downloadBuffer(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        return downloadBuffer(res.headers.location).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) return resolve(null);
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+    }).on("error", () => resolve(null));
+  });
+}
+
+// ─── Parse le tarball (.tgz) sans dépendance externe ─────────────────────────
+// Un .tgz = gzip(tar). On décompresse puis on parse le format TAR à la main.
+function extractFileFromTar(tarBuffer, targetPath) {
+  let offset = 0;
+  while (offset + 512 <= tarBuffer.length) {
+    // Header TAR (512 octets)
+    const header = tarBuffer.slice(offset, offset + 512);
+    const nameRaw = header.slice(0, 100).toString("utf8").replace(/\0/g, "").trim();
+    if (!nameRaw) break; // fin d'archive
+
+    const sizeOctal = header.slice(124, 136).toString("utf8").replace(/\0/g, "").trim();
+    const size = parseInt(sizeOctal, 8) || 0;
+
+    // Prefix (ustar)
+    const prefix = header.slice(345, 500).toString("utf8").replace(/\0/g, "").trim();
+    const fullName = prefix ? `${prefix}/${nameRaw}` : nameRaw;
+
+    offset += 512; // saute le header
+
+    if (fullName.endsWith(targetPath) || fullName === targetPath) {
+      return tarBuffer.slice(offset, offset + size).toString("utf8");
+    }
+
+    // Saute le contenu (arrondi à 512)
+    offset += Math.ceil(size / 512) * 512;
   }
+  return null;
 }
 
-function getDiff(lastTag) {
-  try {
-    const ref = lastTag ? `${lastTag}..HEAD` : "HEAD~5..HEAD";
-    return execSync(`git diff ${ref} --stat`, { encoding: "utf-8" }).trim().slice(0, 1500);
-  } catch {
+async function fetchShardJsFromNpm(version) {
+  const pkgShort = pkg.name.replace("@iksdev/", "");
+  const url = `https://registry.npmjs.org/${pkg.name}/-/${pkgShort}-${version}.tgz`;
+
+  console.log(`  URL: ${url}`);
+  const tgzBuffer = await downloadBuffer(url);
+  if (!tgzBuffer) {
+    console.log("  ❌ Téléchargement échoué");
     return null;
   }
+  console.log(`  ✅ Téléchargé (${(tgzBuffer.length / 1024).toFixed(0)} Ko)`);
+
+  // Décompresse le gzip
+  const tarBuffer = await new Promise((resolve, reject) => {
+    zlib.gunzip(tgzBuffer, (err, result) => {
+      if (err) reject(err);
+      else resolve(result);
+    });
+  });
+
+  // Extrait bin/shard.js
+  const content = extractFileFromTar(tarBuffer, "bin/shard.js");
+  if (!content) {
+    console.log("  ❌ bin/shard.js introuvable dans le tarball");
+  } else {
+    console.log(`  ✅ bin/shard.js extrait (${content.length} chars)`);
+  }
+  return content;
 }
 
-// ─── Gemini changelog ─────────────────────────────────────────────────────────
+// ─── Gemini ───────────────────────────────────────────────────────────────────
 function geminiRequest(prompt) {
   return new Promise((resolve, reject) => {
     const body = JSON.stringify({
       contents: [{ parts: [{ text: prompt }] }],
-      generationConfig: { maxOutputTokens: 300, temperature: 0.3 },
+      generationConfig: { maxOutputTokens: 500, temperature: 0.3 },
     });
-
     const req = https.request(
       {
         hostname: "generativelanguage.googleapis.com",
         path: `/v1beta/models/gemini-1.5-flash:generateContent?key=${GEMINI_KEY}`,
         method: "POST",
-        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body),
+        },
       },
       (res) => {
         let data = "";
-        res.on("data", (chunk) => (data += chunk));
+        res.on("data", (c) => (data += c));
         res.on("end", () => {
           try {
             const json = JSON.parse(data);
-            const text = json.candidates?.[0]?.content?.parts?.[0]?.text;
-            resolve(text || null);
-          } catch {
-            resolve(null);
-          }
+            resolve(json.candidates?.[0]?.content?.parts?.[0]?.text || null);
+          } catch { resolve(null); }
         });
       }
     );
@@ -67,36 +137,36 @@ function geminiRequest(prompt) {
   });
 }
 
-async function generateChangelog(commits, diff) {
-  if (!commits) return null;
-  const prompt = `Tu es un assistant qui génère des changelogs concis et clairs pour des releases npm.
-Voici les commits de la version ${pkg.version} de ${pkg.name} :
+async function generateChangelog(oldCode, newCode, prevVersion) {
+  const maxLen = 6000;
+  const prompt = `Tu es un expert Node.js. Compare ces deux versions du CLI "${pkg.name}".
 
-${commits}
+=== VERSION PRÉCÉDENTE (v${prevVersion}) ===
+${oldCode.slice(0, maxLen)}
 
-${diff ? `Fichiers modifiés :\n${diff}` : ""}
+=== NOUVELLE VERSION (v${pkg.version}) ===
+${newCode.slice(0, maxLen)}
 
-Génère un changelog court (max 5 bullet points) en français, avec des emojis, sans blabla. Format :
-Nouvelle fonctionnalité X
-Correction de Y
-Amélioration de Z`;
+Génère un changelog clair en français (max 6 points) basé uniquement sur les vraies différences de code. Utilise des emojis. Pas d'introduction, juste les bullet points :
+✨ Ajout de X
+🐛 Correction de Y
+⚡ Amélioration de Z
+🗑️ Suppression de W`;
 
   return await geminiRequest(prompt);
 }
 
 // ─── Discord ──────────────────────────────────────────────────────────────────
-function sendDiscord(changelog) {
-  return new Promise((resolve, reject) => {
+function sendDiscord(changelog, prevVersion) {
+  return new Promise((resolve) => {
     const fields = [];
-
     if (changelog) {
       fields.push({
-        name: "📋 Changelog",
+        name: `📋 Changements depuis v${prevVersion}`,
         value: changelog.slice(0, 1024),
         inline: false,
       });
     }
-
     fields.push({
       name: "📦 Mise à jour",
       value: `\`\`\`bash\nnpm i -g ${pkg.name}@latest\n\`\`\``,
@@ -114,7 +184,7 @@ function sendDiscord(changelog) {
         description: `> ${pkg.description}`,
         color: 0x5865f2,
         fields,
-        footer: { text: "Publié le" },
+        footer: { text: `v${prevVersion} → v${pkg.version}` },
         timestamp: new Date().toISOString(),
       }],
     });
@@ -125,20 +195,22 @@ function sendDiscord(changelog) {
         hostname: url.hostname,
         path: url.pathname + url.search,
         method: "POST",
-        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+        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})`);
-          resolve();
         } else {
           res.setEncoding("utf-8");
           res.on("data", (d) => console.error("❌ Erreur Discord :", d));
-          resolve();
         }
+        resolve();
       }
     );
-    req.on("error", reject);
+    req.on("error", (e) => { console.error("❌ Réseau :", e.message); resolve(); });
     req.write(body);
     req.end();
   });
@@ -146,10 +218,30 @@ function sendDiscord(changelog) {
 
 // ─── Main ─────────────────────────────────────────────────────────────────────
 (async () => {
-  console.log("📡 Génération du changelog avec Gemini...");
-  const lastTag = getLastTag();
-  const commits = getCommits(lastTag);
-  const diff = getDiff(lastTag);
-  const changelog = await generateChangelog(commits, diff);
-  await sendDiscord(changelog);
+  console.log("🔍 Récupération de la version précédente sur npm...");
+  const prevVersion = await getPreviousVersion();
+
+  if (!prevVersion) {
+    console.log("⚠️  Pas de version précédente, envoi sans changelog.");
+    await sendDiscord(null, "?");
+    return;
+  }
+
+  console.log(`📥 Téléchargement de shard.js v${prevVersion} depuis npm...`);
+  const oldCode = await fetchShardJsFromNpm(prevVersion);
+
+  const newCode = fs.existsSync("./bin/shard.js")
+    ? fs.readFileSync("./bin/shard.js", "utf-8")
+    : null;
+
+  if (!oldCode || !newCode) {
+    console.log("⚠️  Fichiers introuvables, envoi sans changelog.");
+    await sendDiscord(null, prevVersion);
+    return;
+  }
+
+  console.log("🤖 Analyse des différences avec Gemini...");
+  const changelog = await generateChangelog(oldCode, newCode, prevVersion);
+
+  await sendDiscord(changelog, prevVersion);
 })();

package/package.json

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