@iksdev/shard-cli 0.1.10 → 0.1.12

package/README.md

@@ -48,9 +48,11 @@ shard sync ./MonDossier
 
 ## Notes
 
+- Mode interactif: si tu lances `shard login`, `shard sync` ou `shard share` sans arguments, la CLI te pose les questions.
 - Le CLI stocke la config dans `~/.shard-cli/config.json`.
 - Le CLI stocke l'etat de sync dans `<ton-dossier>/.shard-sync-state.json`.
 - Les uploads passent par `POST /api/files/upload` avec token `Bearer`.
 - Par défaut `shard share` utilise le mode relay: le fichier reste sur ton PC, le serveur stocke seulement metadata + token.
 - Aucun tunnel externe à installer: le serveur Shard relaie directement le flux via websocket.
+- Le relay file id est stable par chemin de fichier: relancer `shard share` sur le meme fichier réactive les anciens liens.
 - Utilise `--upload` pour revenir au mode historique (upload serveur).

package/bin/shard.js

@@ -5,6 +5,8 @@ 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');
 
@@ -36,7 +38,7 @@ Examples:
 `);
 }
 
-function parseArgs(rawArgs) {
+function parseArgs(rawArgs) {
   const args = [...rawArgs];
   const command = args.shift();
   const positionals = [];
@@ -57,8 +59,67 @@ function parseArgs(rawArgs) {
     flags[key] = next;
     i += 1;
   }
-  return { command, positionals, flags };
-}
+  return { command, positionals, flags };
+}
+
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+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 = String(answer || '').trim();
+  return trimmed || String(defaultValue || '').trim();
+}
+
+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();
@@ -112,15 +173,24 @@ async function httpJson(url, options = {}) {
   return data;
 }
 
-async function login(flags) {
-  const username = flags.username;
-  const password = flags.password;
-  if (!username || !password) {
-    throw new Error('Usage: shard login --username <name> --password <pass> [--server <url>]');
-  }
-
-  const config = await readConfig();
-  const server = getServer(flags, config);
+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',
@@ -319,8 +389,25 @@ function toWebSocketUrl(serverUrl, 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) {
-  const target = positionals[0];
+  let target = 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]');
   }
@@ -353,7 +440,7 @@ async function shareFile(positionals, flags) {
   const fileName = path.basename(absPath);
   if (localMode) {
     const mimeType = guessMime(absPath);
-    const relayFileId = crypto.randomBytes(12).toString('base64url');
+    const relayFileId = stableRelayFileId(absPath);
     const wsUrl = toWebSocketUrl(server, token);
     const relaySocket = new WebSocket(wsUrl);
 
@@ -375,11 +462,11 @@ async function shareFile(positionals, flags) {
         reject(new Error('Timeout connexion relay'));
       }, 15000);
 
-      relaySocket.addEventListener('open', () => {
+      relaySocket.on('open', () => {
         clearTimeout(timer);
         resolve();
       });
-      relaySocket.addEventListener('error', (event) => {
+      relaySocket.on('error', (event) => {
         clearTimeout(timer);
         reject(new Error(`Echec connexion relay: ${event?.message || 'ws error'}`));
       });
@@ -390,9 +477,9 @@ async function shareFile(positionals, flags) {
 
       const helloPromise = new Promise((resolve, reject) => {
         const timer = setTimeout(() => reject(new Error('Handshake relay timeout')), 12000);
-        relaySocket.addEventListener('message', (event) => {
+        relaySocket.on('message', (event) => {
           let msg = null;
-          try { msg = JSON.parse(String(event.data || '')); } catch (_) { return; }
+          try { msg = JSON.parse(String(event || '')); } catch (_) { return; }
           if (!msg || typeof msg !== 'object') return;
           if (msg.type === 'hello_ack' && msg.relayClientId) {
             clearTimeout(timer);
@@ -403,9 +490,11 @@ async function shareFile(positionals, flags) {
       });
       await helloPromise;
 
-      relaySocket.addEventListener('message', async (event) => {
+      relaySocket.send(JSON.stringify({ type: 'register_file', relayFileId }));
+
+      relaySocket.on('message', async (event) => {
         let msg = null;
-        try { msg = JSON.parse(String(event.data || '')); } catch (_) { return; }
+        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;
@@ -443,7 +532,6 @@ async function shareFile(positionals, flags) {
         fileName,
         fileSize: st.size,
         mimeType,
-        relayClientId,
         relayFileId
       };
       if (limits !== undefined && limits > 0) payload.maxDownloads = limits;
@@ -463,12 +551,13 @@ async function shareFile(positionals, flags) {
       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.addEventListener('close', () => resolve());
+        relaySocket.on('close', () => resolve());
       });
       clearInterval(heartbeat);
       for (const sig of stopSignals) {
@@ -782,11 +871,14 @@ async function mirrorRealtime(server, token, rootDir, state, intervalMs) {
   process.off('SIGTERM', onStop);
 }
 
-async function syncFolder(positionals, flags) {
-  const target = positionals[0];
-  if (!target) {
-    throw new Error('Usage: shard sync <folder> [--server <url>] [--dry-run] [--force] [--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))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iksdev/shard-cli",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "CLI pour synchroniser un dossier local avec Shard",
   "bin": {
     "shard": "bin/shard.js"
@@ -9,6 +9,9 @@
   "scripts": {
     "check": "node --check bin/shard.js"
   },
+  "dependencies": {
+    "ws": "^8.18.3"
+  },
   "engines": {
     "node": ">=20.0.0"
   },