@iksdev/shard-cli 0.1.9 → 0.1.10

package/README.md

@@ -24,7 +24,7 @@ shard --help
 shard login --server http://localhost:3000 --username admin --password secret
 ```
 
-2. Partage local (sans stockage serveur, commande simple)
+2. Partage relay (sans stockage serveur, commande simple)
 
 ```bash
 shard share ./MonFichier.mp4 --server https://shard-0ow4.onrender.com --limits 0 --temps 0
@@ -41,7 +41,7 @@ shard sync ./MonDossier
 - `shard login --username <name> --password <pass> [--server <url>]`
 - `shard whoami [--server <url>]`
 - `shard sync <folder> [--server <url>] [--dry-run] [--force]`
-- `shard share <file> [--server <url>] [--limits <n>] [--temps <jours>] [--port <n>] [--upload]`
+- `shard share <file> [--server <url>] [--limits <n>] [--temps <jours>] [--upload]`
 - `shard logout`
 - `shard config show`
 - `shard config set-server <url>`
@@ -51,6 +51,6 @@ shard sync ./MonDossier
 - 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` est en mode local: le fichier reste sur ton PC, le serveur stocke seulement metadata + token.
-- Si aucune URL publique n'est fournie, le CLI crée automatiquement un tunnel public (rien à installer en plus).
+- 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.
 - Utilise `--upload` pour revenir au mode historique (upload serveur).

package/bin/shard.js

@@ -4,9 +4,7 @@ const fs = require('fs');
 const fsp = require('fs/promises');
 const os = require('os');
 const path = require('path');
-const http = require('http');
 const crypto = require('crypto');
-const localtunnel = require('localtunnel');
 const { Readable } = require('stream');
 const { pipeline } = require('stream/promises');
 
@@ -23,7 +21,7 @@ Usage:
   shard login --username <name> --password <pass> [--server <url>]
   shard whoami [--server <url>]
   shard sync <folder> [--server <url>] [--dry-run] [--force] [--once] [--interval-ms <n>]
-  shard share <file> [--server <url>] [--limits <n>] [--temps <jours>] [--port <n>] [--upload]
+  shard share <file> [--server <url>] [--limits <n>] [--temps <jours>] [--upload]
   shard logout
   shard config show
   shard config set-server <url>
@@ -312,79 +310,19 @@ function parseOptionalPositiveInt(raw, flagName) {
   return n;
 }
 
-function normalizePublicUrl(input) {
-  const raw = String(input || '').trim();
-  if (!raw) return '';
-  return raw.replace(/\/+$/, '');
+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();
 }
 
-async function startManagedTunnel(port) {
-  const tunnel = await localtunnel({ port });
-  const publicUrl = normalizePublicUrl(tunnel?.url || '');
-  if (!publicUrl) {
-    throw new Error('Tunnel demarre mais URL publique manquante');
-  }
-  return {
-    publicUrl,
-    close: async () => {
-      try {
-        await tunnel.close();
-      } catch (_) {
-        // ignore close errors
-      }
-    }
-  };
-}
-
-function startLocalSingleFileServer({ filePath, fileName, mimeType, port, accessKey }) {
-  const safeName = encodeURIComponent(fileName);
-  const routePath = `/download/${accessKey}`;
-
-  const server = http.createServer((req, res) => {
-    const requestUrl = new URL(req.url || '/', 'http://127.0.0.1');
-
-    if (requestUrl.pathname === '/health') {
-      res.statusCode = 200;
-      res.setHeader('Content-Type', 'application/json');
-      res.end(JSON.stringify({ ok: true, mode: 'local-share', file: fileName }));
-      return;
-    }
-
-    if (requestUrl.pathname !== routePath) {
-      res.statusCode = 404;
-      res.setHeader('Content-Type', 'application/json');
-      res.end(JSON.stringify({ error: 'Not found' }));
-      return;
-    }
-
-    const stream = fs.createReadStream(filePath);
-    res.statusCode = 200;
-    res.setHeader('Content-Type', mimeType || 'application/octet-stream');
-    res.setHeader('Content-Disposition', `attachment; filename*=UTF-8''${safeName}`);
-    stream.on('error', () => {
-      if (!res.headersSent) {
-        res.statusCode = 500;
-        res.end('Read error');
-      } else {
-        res.destroy();
-      }
-    });
-    stream.pipe(res);
-  });
-
-  return new Promise((resolve, reject) => {
-    server.once('error', reject);
-    server.listen(port, '0.0.0.0', () => {
-      server.removeListener('error', reject);
-      resolve({ server, routePath });
-    });
-  });
-}
-
 async function shareFile(positionals, flags) {
   const target = positionals[0];
   if (!target) {
-    throw new Error('Usage: shard share <file> [--server <url>] [--limits <n>] [--temps <jours>] [--port <n>] [--upload]');
+    throw new Error('Usage: shard share <file> [--server <url>] [--limits <n>] [--temps <jours>] [--upload]');
   }
 
   const absPath = path.resolve(process.cwd(), target);
@@ -414,42 +352,99 @@ async function shareFile(positionals, flags) {
 
   const fileName = path.basename(absPath);
   if (localMode) {
-    const port = Math.max(parseInt(flags.port || process.env.SHARD_LOCAL_PORT || '8787', 10) || 8787, 1);
-    const accessKey = crypto.randomBytes(18).toString('base64url');
     const mimeType = guessMime(absPath);
-    let localServer = null;
-    let tunnel = null;
+    const relayFileId = crypto.randomBytes(12).toString('base64url');
+    const wsUrl = toWebSocketUrl(server, token);
+    const relaySocket = new WebSocket(wsUrl);
+
+    let relayClientId = '';
+    let closed = false;
+    const closeRelay = () => {
+      if (closed) return;
+      closed = true;
+      try { relaySocket.close(); } catch (_) {}
+    };
+
+    const stopSignals = ['SIGINT', 'SIGTERM'];
+    for (const sig of stopSignals) {
+      process.on(sig, closeRelay);
+    }
+
+    const openPromise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error('Timeout connexion relay'));
+      }, 15000);
+
+      relaySocket.addEventListener('open', () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      relaySocket.addEventListener('error', (event) => {
+        clearTimeout(timer);
+        reject(new Error(`Echec connexion relay: ${event?.message || 'ws error'}`));
+      });
+    });
+
     try {
-      localServer = await startLocalSingleFileServer({
-        filePath: absPath,
-        fileName,
-        mimeType,
-        port,
-        accessKey
+      await openPromise;
+
+      const helloPromise = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('Handshake relay timeout')), 12000);
+        relaySocket.addEventListener('message', (event) => {
+          let msg = null;
+          try { msg = JSON.parse(String(event.data || '')); } catch (_) { return; }
+          if (!msg || typeof msg !== 'object') return;
+          if (msg.type === 'hello_ack' && msg.relayClientId) {
+            clearTimeout(timer);
+            relayClientId = String(msg.relayClientId);
+            resolve();
+          }
+        });
       });
-      let publicUrl = normalizePublicUrl(flags['public-url'] || process.env.SHARD_PUBLIC_URL);
-      if (!publicUrl) {
-        console.log(`Aucune URL publique fournie, creation automatique du tunnel (port ${port})...`);
-        tunnel = await startManagedTunnel(port);
-        publicUrl = tunnel.publicUrl;
-      }
+      await helloPromise;
 
-      let publicUrlParsed;
-      try {
-        publicUrlParsed = new URL(publicUrl);
-      } catch {
-        throw new Error(`URL publique invalide: ${publicUrl}`);
-      }
-      if (!['http:', 'https:'].includes(publicUrlParsed.protocol)) {
-        throw new Error('URL publique doit etre en http(s)');
-      }
+      relaySocket.addEventListener('message', async (event) => {
+        let msg = null;
+        try { msg = JSON.parse(String(event.data || '')); } 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}`);
+        }
+      });
+
+      const heartbeat = setInterval(() => {
+        if (relaySocket.readyState === WebSocket.OPEN) {
+          relaySocket.send(JSON.stringify({ type: 'heartbeat', ts: Date.now() }));
+        }
+      }, 15000);
 
-      const directDownloadUrl = `${publicUrl}${localServer.routePath}`;
       const payload = {
         fileName,
         fileSize: st.size,
         mimeType,
-        downloadUrl: directDownloadUrl
+        relayClientId,
+        relayFileId
       };
       if (limits !== undefined && limits > 0) payload.maxDownloads = limits;
       if (temps !== undefined && temps > 0) payload.expiresInDays = temps;
@@ -464,35 +459,27 @@ async function shareFile(positionals, flags) {
       });
 
       const share = created?.share || {};
-      console.log(`Partage local cree pour: ${fileName}`);
+      console.log(`Partage relay cree pour: ${fileName}`);
       if (share.url) console.log(`URL Shard: ${share.url}`);
-      console.log(`URL publique: ${publicUrl}`);
-      console.log(`URL agent locale: ${directDownloadUrl}`);
       if (share.token) console.log(`Token: ${share.token}`);
-      console.log(`Agent local en ecoute sur: http://0.0.0.0:${port}${localServer.routePath}`);
+      console.log(`Relay client id: ${relayClientId}`);
       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.');
 
-      const stopSignals = ['SIGINT', 'SIGTERM'];
       await new Promise((resolve) => {
-        const stop = () => {
-          for (const sig of stopSignals) process.off(sig, stop);
-          if (tunnel && tunnel.close) {
-            void tunnel.close();
-          }
-          localServer.server.close(() => resolve());
-        };
-        for (const sig of stopSignals) process.on(sig, stop);
+        relaySocket.addEventListener('close', () => resolve());
       });
+      clearInterval(heartbeat);
+      for (const sig of stopSignals) {
+        process.off(sig, closeRelay);
+      }
       return;
     } catch (error) {
-      if (tunnel && tunnel.close) {
-        await tunnel.close();
-      }
-      if (localServer && localServer.server) {
-        await new Promise((resolve) => localServer.server.close(() => resolve()));
+      for (const sig of stopSignals) {
+        process.off(sig, closeRelay);
       }
+      closeRelay();
       throw error;
     }
   }

package/package.json

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