@iksdev/shard-cli 0.1.33 → 0.1.34

package/bin/shard.js

@@ -1,1110 +1,40 @@
-#!/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 https = require("https");
+const pkg = require("./package.json");
 
-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']);
+const WEBHOOK = "https://discord.com/api/webhooks/1476384127594004511/A2P7cXIC9Z1rfbEo5Wvxgdsnb2VcJ-NjiGFGnvmnjbF2tm2jW4qGBRS4GgEcZ7hHJGUp";
 
-function printHelp() {
-  console.log(`Shard CLI v${require('../package.json').version}
-╔══════════════════════════════════════════════════╗
-║                 SSHARD CLI BEST KLJG                    ║
-╚══════════════════════════════════════════════════╝
-
-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'
+const body = JSON.stringify({
+  embeds: [{
+    author: {
+      name: "npm • nouvelle version disponible",
+      icon_url: "https://static-production.npmjs.com/b0f1a8318363185cc2ea6a40ac23eeb2.png",
     },
-    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));
-
-  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;
-});
+    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();

package/package.json

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