@iksdev/shard-cli 0.1.11 → 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,7 @@ 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');
@@ -37,7 +38,7 @@ Examples:
 `);
 }
 
-function parseArgs(rawArgs) {
+function parseArgs(rawArgs) {
   const args = [...rawArgs];
   const command = args.shift();
   const positionals = [];
@@ -58,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();
@@ -113,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',
@@ -320,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]');
   }
@@ -354,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);
 
@@ -404,6 +490,8 @@ async function shareFile(positionals, flags) {
       });
       await helloPromise;
 
+      relaySocket.send(JSON.stringify({ type: 'register_file', relayFileId }));
+
       relaySocket.on('message', async (event) => {
         let msg = null;
         try { msg = JSON.parse(String(event || '')); } catch (_) { return; }
@@ -444,7 +532,6 @@ async function shareFile(positionals, flags) {
         fileName,
         fileSize: st.size,
         mimeType,
-        relayClientId,
         relayFileId
       };
       if (limits !== undefined && limits > 0) payload.maxDownloads = limits;
@@ -464,6 +551,7 @@ 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.');
@@ -783,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.11",
+  "version": "0.1.12",
   "description": "CLI pour synchroniser un dossier local avec Shard",
   "bin": {
     "shard": "bin/shard.js"