@balaji003/lantransfer 1.0.4 → 1.0.6

package/README.md

@@ -0,0 +1,70 @@
+# lantransfer
+
+Peer-to-peer file sharing over your local network. Zero dependencies. Works on Windows, macOS, and Linux.
+
+```
+npm install -g @balaji003/lantransfer
+lantransfer
+```
+
+A browser window opens automatically — select a file, pick a nearby device, and send.
+
+## Features
+
+- **Zero dependencies** — uses only Node.js built-in modules
+- **Auto-discovery** — finds devices on your LAN automatically via HTTP subnet scanning (no firewall rules needed) + UDP broadcast fallback
+- **Browser UI** — clean dark-themed interface, no extra apps to install
+- **Cross-platform** — Windows, macOS, Linux
+- **Accept/Reject prompt** — incoming files must be approved before transfer
+- **Progress tracking** — real-time speed and progress for all transfers
+- **XOR encrypted** — file data is obfuscated during transfer
+- **Native file picker** — uses your OS file dialog (PowerShell on Windows, osascript on macOS, zenity/kdialog on Linux)
+
+## Usage
+
+### Install globally and run
+
+```bash
+npm install -g @balaji003/lantransfer
+lantransfer
+```
+
+### Or run directly with npx
+
+```bash
+npx @balaji003/lantransfer
+```
+
+### Or clone and run
+
+```bash
+git clone https://github.com/user/lantransfer.git
+cd lantransfer
+node server.js
+```
+
+## How it works
+
+1. Run `lantransfer` on two (or more) devices connected to the same WiFi/LAN
+2. Each device scans the local subnet to find other instances — no firewall configuration needed
+3. Devices appear in the sidebar under "Nearby Devices"
+4. Click **Browse** to select a file, select a device, and click **Send**
+5. The receiver sees a popup to **Accept** or **Reject**
+6. Accepted files are saved to the `Downloads` folder
+
+## Ports
+
+| Port  | Protocol | Purpose              |
+|-------|----------|----------------------|
+| 3000  | HTTP     | Web UI + discovery   |
+| 34254 | UDP      | Broadcast discovery (fallback) |
+| 34255 | TCP      | File transfer        |
+
+## Requirements
+
+- Node.js >= 16.0.0
+- Both devices on the same local network
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@balaji003/lantransfer",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "LAN File Transfer — peer-to-peer file sharing over local network. Zero dependencies.",
   "main": "server.js",
   "bin": {
@@ -9,7 +9,8 @@
   "files": [
     "server.js",
     "public/",
-    "bin/"
+    "bin/",
+    "README.md"
   ],
   "scripts": {
     "start": "node server.js"

package/public/index.html

@@ -47,7 +47,14 @@
     }
     .header-left { display: flex; align-items: center; gap: 16px; }
     .logo { font-size: 20px; font-weight: 700; color: #8cc8ff; }
-    .device-info { color: var(--text-dim); font-size: 13px; }
+    .device-info { color: var(--text-dim); font-size: 13px; display: flex; align-items: center; gap: 6px; }
+    .device-name-edit {
+      background: transparent; border: 1px solid transparent; color: var(--text);
+      font-size: 13px; font-family: inherit; padding: 2px 6px; border-radius: 4px;
+      width: 160px; outline: none; transition: border-color 0.2s;
+    }
+    .device-name-edit:hover { border-color: var(--border); }
+    .device-name-edit:focus { border-color: var(--accent); background: var(--surface-hover); }
 
     .toggle {
       display: flex; align-items: center; gap: 8px;
@@ -135,6 +142,22 @@
     .file-info { color: var(--text-dim); font-size: 13px; }
     .file-info.has-file { color: var(--text); font-weight: 500; }
 
+    .file-list { margin-top: 12px; }
+    .file-item {
+      display: flex; align-items: center; justify-content: space-between;
+      padding: 8px 12px; background: var(--surface); border-radius: var(--radius);
+      margin-bottom: 4px; font-size: 13px;
+    }
+    .file-item-left { display: flex; align-items: center; gap: 8px; overflow: hidden; }
+    .file-item-name { font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+    .file-item-size { color: var(--text-dim); white-space: nowrap; }
+    .file-item-radio { accent-color: var(--accent); cursor: pointer; }
+    .file-item-remove {
+      background: none; border: none; color: var(--text-dim); cursor: pointer;
+      font-size: 16px; padding: 0 4px; line-height: 1; transition: color 0.12s;
+    }
+    .file-item-remove:hover { color: var(--red); }
+
     /* ── Transfers ── */
     .transfers-section { flex: 1; overflow-y: auto; padding: 16px 24px; }
     .transfer {
@@ -216,7 +239,11 @@
   <div class="header">
     <div class="header-left">
       <div class="logo">&#8652; LAN Transfer</div>
-      <div class="device-info" id="device-info"></div>
+      <div class="device-info">
+        <input class="device-name-edit" id="device-name" type="text" maxlength="50" title="Click to edit device name" />
+        <span style="color:var(--text-dim)">&#183;</span>
+        <span id="local-ip"></span>
+      </div>
     </div>
     <div class="header-right">
       <div class="toggle" id="toggle" onclick="api('toggle')">
@@ -243,9 +270,10 @@
       <div class="send-panel">
         <div class="send-title">Send File</div>
         <div class="send-row">
-          <button class="btn btn-browse" onclick="api('browse')">Browse</button>
-          <span class="file-info" id="file-info">No file selected</span>
+          <button class="btn btn-browse" id="browse-btn" onclick="doBrowse()">Browse</button>
+          <span class="file-info" id="file-info">No files added</span>
         </div>
+        <div class="file-list" id="file-list"></div>
         <div class="send-row" style="margin-top: 12px;">
           <button class="btn btn-send" id="send-btn" onclick="doSend()" disabled>Send</button>
         </div>
@@ -273,6 +301,8 @@
   // ──────────────────────────────────────────────────────────────────────────
   let state = {};
   let selectedPeerId = null;
+  let selectedFileId = null;
+  let browsing = false;
 
   // ──────────────────────────────────────────────────────────────────────────
   // SSE connection
@@ -282,6 +312,10 @@
     evtSource = new EventSource('/events');
     evtSource.onmessage = e => {
       state = JSON.parse(e.data);
+      // Auto-select the latest file if none selected
+      if (!selectedFileId && state.sharedFiles && state.sharedFiles.length > 0) {
+        selectedFileId = state.sharedFiles[state.sharedFiles.length - 1].id;
+      }
       render();
     };
     evtSource.onopen = () => {
@@ -297,7 +331,7 @@
   // API
   // ──────────────────────────────────────────────────────────────────────────
   function api(endpoint, data) {
-    fetch('/api/' + endpoint, {
+    return fetch('/api/' + endpoint, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(data || {}),
@@ -309,9 +343,28 @@
     render();
   }
 
+  function selectFile(id) {
+    selectedFileId = id;
+    render();
+  }
+
+  function removeFile(id) {
+    api('remove-file', { fileId: id });
+    if (selectedFileId === id) selectedFileId = null;
+  }
+
+  async function doBrowse() {
+    if (browsing) return;
+    browsing = true;
+    document.getElementById('browse-btn').textContent = 'Opening...';
+    await api('browse');
+    browsing = false;
+    document.getElementById('browse-btn').textContent = 'Browse';
+  }
+
   function doSend() {
-    if (selectedPeerId && state.selectedFile) {
-      api('send', { peerId: selectedPeerId });
+    if (selectedPeerId && selectedFileId) {
+      api('send', { peerId: selectedPeerId, fileId: selectedFileId });
     }
   }
 
@@ -326,13 +379,29 @@
     }
   }
 
+  // ──────────────────────────────────────────────────────────────────────────
+  // Device name editing
+  // ──────────────────────────────────────────────────────────────────────────
+  const nameInput = document.getElementById('device-name');
+  let nameLoaded = false;
+  nameInput.addEventListener('change', () => {
+    const val = nameInput.value.trim();
+    if (val) api('rename', { name: val });
+  });
+  nameInput.addEventListener('keydown', e => {
+    if (e.key === 'Enter') nameInput.blur();
+  });
+
   // ──────────────────────────────────────────────────────────────────────────
   // Render
   // ──────────────────────────────────────────────────────────────────────────
   function render() {
-    // Header
-    const info = document.getElementById('device-info');
-    info.textContent = (state.deviceName || '') + '  \u00B7  ' + (state.localIP || '');
+    // Device name (only set once to avoid clobbering user edits)
+    if (!nameLoaded && state.deviceName) {
+      nameInput.value = state.deviceName;
+      nameLoaded = true;
+    }
+    document.getElementById('local-ip').textContent = state.localIP || '';
 
     // Toggle
     const toggle = document.getElementById('toggle');
@@ -350,7 +419,6 @@
     if (!state.peers || state.peers.length === 0) {
       peersEl.innerHTML = '<div class="empty-msg">Searching for nearby devices&hellip;<br><br><small>Make sure both devices are on the same WiFi</small></div>';
     } else {
-      // Validate selection still exists
       if (selectedPeerId && !state.peers.some(p => p.id === selectedPeerId)) {
         selectedPeerId = null;
       }
@@ -362,26 +430,47 @@
       ).join('');
     }
 
-    // File info
+    // Shared files
+    const files = state.sharedFiles || [];
     const fileInfoEl = document.getElementById('file-info');
-    if (state.selectedFile) {
-      fileInfoEl.className = 'file-info has-file';
-      fileInfoEl.textContent = state.selectedFile.name + '  \u00B7  ' + formatSize(state.selectedFile.size);
-    } else {
+    const fileListEl = document.getElementById('file-list');
+
+    if (files.length === 0) {
       fileInfoEl.className = 'file-info';
-      fileInfoEl.textContent = 'No file selected';
+      fileInfoEl.textContent = 'No files added';
+      fileListEl.innerHTML = '';
+      selectedFileId = null;
+    } else {
+      fileInfoEl.className = 'file-info has-file';
+      fileInfoEl.textContent = files.length + ' file' + (files.length > 1 ? 's' : '') + ' ready to send';
+      // Validate selection
+      if (selectedFileId && !files.some(f => f.id === selectedFileId)) {
+        selectedFileId = files[files.length - 1].id;
+      }
+      fileListEl.innerHTML = files.map(f =>
+        '<div class="file-item">'
+        + '<div class="file-item-left">'
+        + '<input type="radio" name="sel-file" class="file-item-radio" '
+        + (selectedFileId === f.id ? 'checked ' : '')
+        + 'onchange="selectFile(\'' + esc(f.id) + '\')" />'
+        + '<span class="file-item-name">' + esc(f.name) + '</span>'
+        + '<span class="file-item-size">' + formatSize(f.size) + '</span>'
+        + '</div>'
+        + '<button class="file-item-remove" onclick="removeFile(\'' + esc(f.id) + '\')" title="Remove">&times;</button>'
+        + '</div>'
+      ).join('');
     }
 
     // Send button
     const sendBtn = document.getElementById('send-btn');
-    const canSend = !!(selectedPeerId && state.selectedFile && state.peers && state.peers.some(p => p.id === selectedPeerId));
+    const canSend = !!(selectedPeerId && selectedFileId && state.peers && state.peers.some(p => p.id === selectedPeerId));
     sendBtn.disabled = !canSend;
     if (canSend) {
       const peer = state.peers.find(p => p.id === selectedPeerId);
       sendBtn.textContent = 'Send to ' + (peer ? peer.name : 'peer');
-    } else if (selectedPeerId && !state.selectedFile) {
+    } else if (selectedPeerId && !selectedFileId) {
       sendBtn.textContent = 'Select a file first';
-    } else if (!selectedPeerId && state.selectedFile) {
+    } else if (!selectedPeerId && selectedFileId) {
       sendBtn.textContent = 'Select a device first';
     } else {
       sendBtn.textContent = 'Send';

package/server.js

@@ -31,16 +31,39 @@ const XOR_KEY = Buffer.from('LAN-XFER-KEY-2024');
 const PEER_TIMEOUT = 10_000;   // ms
 const BROADCAST_INTERVAL = 3_000; // ms
 
+// ──────────────────────────────────────────────────────────────────────────────
+// Persistent config (device name)
+// ──────────────────────────────────────────────────────────────────────────────
+const CONFIG_PATH = path.join(os.homedir(), '.lantransfer.json');
+
+function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch { return {}; }
+}
+
+function saveConfig(cfg) {
+  try {
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+    console.log(`  [config] Saved to ${CONFIG_PATH}`);
+  } catch (e) {
+    console.error(`  [config] Failed to save: ${e.message}`);
+  }
+}
+
+const config = loadConfig();
+
 // ──────────────────────────────────────────────────────────────────────────────
 // Application state
 // ──────────────────────────────────────────────────────────────────────────────
 let isDiscoverable = true;
-const deviceName = os.hostname();
-let selectedFile = null;              // { path, name, size }
+let deviceName = config.deviceName || os.hostname();
+const sharedFiles = [];               // [ { id, path, name, size } ]
 const peers = new Map();              // id → { device_name, ip, tcp_port, last_seen }
 const transfers = [];                 // [ TransferEntry ]
 const pendingRequests = new Map();    // id → { filename, size, senderName, resolve }
 let idCounter = 0;
+let browseInProgress = false;
 
 // ──────────────────────────────────────────────────────────────────────────────
 // SSE (Server-Sent Events) clients
@@ -80,9 +103,8 @@ function serializeState() {
     peers: [...peers.entries()].map(([id, p]) => ({
       id, name: p.device_name, ip: p.ip,
     })),
-    selectedFile: selectedFile
-      ? { name: selectedFile.name, size: selectedFile.size }
-      : null,
+    sharedFiles: sharedFiles.map(f => ({ id: f.id, name: f.name, size: f.size })),
+    selectedFileId: sharedFiles.length > 0 ? sharedFiles[sharedFiles.length - 1].id : null,
     transfers: transfers.map(t => ({
       id: t.id, filename: t.filename, size: t.size,
       direction: t.direction, peerName: t.peerName,
@@ -165,6 +187,25 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  // ── Ping endpoint for HTTP-based discovery ──
+  if (req.method === 'GET' && req.url === '/api/ping') {
+    if (!isDiscoverable) {
+      res.writeHead(403);
+      res.end('Hidden');
+      return;
+    }
+    res.writeHead(200, {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*',
+    });
+    res.end(JSON.stringify({
+      app: 'lantransfer',
+      device_name: deviceName,
+      tcp_port: TRANSFER_PORT,
+    }));
+    return;
+  }
+
   // ── SSE stream ──
   if (req.method === 'GET' && req.url === '/events') {
     res.writeHead(200, {
@@ -186,20 +227,54 @@ const server = http.createServer(async (req, res) => {
 
     if (req.url === '/api/toggle') {
       isDiscoverable = !isDiscoverable;
+      console.log(`  [toggle] Discoverable: ${isDiscoverable}`);
     }
     else if (req.url === '/api/browse') {
-      const fp = await openFileDialog();
-      if (fp) {
-        try {
-          const s = fs.statSync(fp);
-          selectedFile = { path: fp, name: path.basename(fp), size: s.size };
-        } catch { selectedFile = null; }
+      if (browseInProgress) {
+        console.log('  [browse] Dialog already open, ignoring');
+      } else {
+        browseInProgress = true;
+        console.log('  [browse] Opening file dialog...');
+        const fp = await openFileDialog();
+        browseInProgress = false;
+        if (fp) {
+          try {
+            const s = fs.statSync(fp);
+            const file = { id: String(idCounter++), path: fp, name: path.basename(fp), size: s.size };
+            sharedFiles.push(file);
+            console.log(`  [browse] Added: ${file.name} (${formatSize(file.size)})`);
+          } catch (e) {
+            console.error(`  [browse] Error reading file: ${e.message}`);
+          }
+        } else {
+          console.log('  [browse] Cancelled');
+        }
+      }
+    }
+    else if (req.url === '/api/remove-file') {
+      const idx = sharedFiles.findIndex(f => f.id === data.fileId);
+      if (idx !== -1) {
+        console.log(`  [files] Removed: ${sharedFiles[idx].name}`);
+        sharedFiles.splice(idx, 1);
       }
     }
     else if (req.url === '/api/send') {
       const peer = peers.get(data.peerId);
-      if (peer && selectedFile) {
-        sendFile(peer, { ...selectedFile });
+      const file = sharedFiles.find(f => f.id === data.fileId);
+      if (peer && file) {
+        console.log(`  [send] ${file.name} -> ${peer.device_name} (${peer.ip})`);
+        sendFile(peer, { ...file });
+      } else {
+        console.log(`  [send] Failed — peer: ${!!peer}, file: ${!!file}`);
+      }
+    }
+    else if (req.url === '/api/rename') {
+      const newName = (data.name || '').trim();
+      if (newName && newName.length <= 50) {
+        deviceName = newName;
+        config.deviceName = newName;
+        saveConfig(config);
+        console.log(`  [rename] Device name set to: ${deviceName}`);
       }
     }
     else if (req.url === '/api/respond') {
@@ -207,6 +282,7 @@ const server = http.createServer(async (req, res) => {
       if (pending) {
         pending.resolve(!!data.accepted);
         pendingRequests.delete(data.requestId);
+        console.log(`  [respond] ${data.accepted ? 'Accepted' : 'Rejected'} transfer ${data.requestId}`);
       }
     }
     else if (req.url === '/api/shutdown') {
@@ -253,7 +329,6 @@ const udp = dgram.createSocket({ type: 'udp4', reuseAddr: true });
 
 udp.on('listening', () => {
   udp.setBroadcast(true);
-  console.log(`  Discovery  UDP :${DISCOVERY_PORT}`);
 });
 
 udp.on('message', (msg, rinfo) => {
@@ -311,9 +386,7 @@ tcpServer.on('error', err => {
   console.error('  Is another instance running? (port conflict on TCP ' + TRANSFER_PORT + ')');
 });
 
-tcpServer.listen(TRANSFER_PORT, () => {
-  console.log(`  Transfer   TCP :${TRANSFER_PORT}`);
-});
+tcpServer.listen(TRANSFER_PORT);
 
 async function handleIncoming(socket) {
   // Read header length (8 bytes, little-endian u64)
@@ -504,52 +577,83 @@ function formatSize(bytes) {
 }
 
 // ──────────────────────────────────────────────────────────────────────────────
-// Windows Firewall check
+// HTTP-based discovery (no firewall rules needed — outbound TCP only)
 // ──────────────────────────────────────────────────────────────────────────────
-function checkWindowsFirewall() {
-  if (process.platform !== 'win32') return;
-
-  const ruleName = 'LAN Transfer (lantransfer)';
-  const nodeExe = process.execPath;
-
-  // Check if a firewall rule already exists
-  exec(`netsh advfirewall firewall show rule name="${ruleName}"`, { windowsHide: true }, (err, stdout) => {
-    if (!err && stdout.includes(ruleName)) {
-      if (stdout.includes('Enabled:') && stdout.includes('Yes')) {
-        console.log('  Firewall:  Allowed');
-        return;
+function getSubnetIPs() {
+  const results = [];
+  for (const ifaces of Object.values(os.networkInterfaces())) {
+    for (const iface of ifaces) {
+      if (iface.family === 'IPv4' && !iface.internal && iface.netmask) {
+        const ipParts = iface.address.split('.').map(Number);
+        const maskParts = iface.netmask.split('.').map(Number);
+        // Only scan /24 or smaller subnets to keep it fast
+        if (maskParts[2] === 255) {
+          const base = ipParts.slice(0, 3).join('.');
+          for (let i = 1; i < 255; i++) {
+            const ip = `${base}.${i}`;
+            if (ip !== iface.address) results.push(ip);
+          }
+        }
       }
     }
+  }
+  return results;
+}
 
-    // No rule — prompt user via UAC elevation
-    console.log('');
-    console.log('  !! Firewall rule not found for LAN Transfer.');
-    console.log('  !! Device discovery requires UDP/TCP through Windows Firewall.');
-    console.log('  !! Requesting permission (UAC prompt)...');
-    console.log('');
-
-    const addCmd = [
-      `netsh advfirewall firewall add rule name="${ruleName}" dir=in action=allow protocol=UDP localport=${DISCOVERY_PORT} program="${nodeExe}" enable=yes`,
-      `netsh advfirewall firewall add rule name="${ruleName}" dir=in action=allow protocol=TCP localport=${TRANSFER_PORT} program="${nodeExe}" enable=yes`,
-    ].join(' & ');
-
-    const psCmd = `powershell -Command "Start-Process cmd -ArgumentList '/c ${addCmd.replace(/"/g, '\\"')}' -Verb RunAs -Wait"`;
-
-    exec(psCmd, { windowsHide: false, timeout: 60_000 }, (err2) => {
-      if (err2) {
-        console.log('  !! Firewall permission denied. Discovery will NOT work.');
-        console.log('  !! To fix manually:');
-        console.log('  !!   1. Open Windows Security > Firewall & network protection');
-        console.log('  !!   2. Click "Allow an app through firewall"');
-        console.log('  !!   3. Add Node.js and allow Private + Public networks');
-        console.log('');
-      } else {
-        console.log('  Firewall:  Rule added! Discovery should work now.');
-      }
+function pingHost(ip) {
+  return new Promise(resolve => {
+    const req = http.get(`http://${ip}:${HTTP_PORT}/api/ping`, { timeout: 800 }, res => {
+      let body = '';
+      res.on('data', c => body += c);
+      res.on('end', () => {
+        try {
+          const d = JSON.parse(body);
+          if (d.app === 'lantransfer' && d.device_name !== deviceName) {
+            resolve({ ip, device_name: d.device_name, tcp_port: d.tcp_port });
+          } else resolve(null);
+        } catch { resolve(null); }
+      });
     });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
   });
 }
 
+let httpScanning = false;
+async function httpDiscoveryScan() {
+  if (!isDiscoverable || httpScanning) return;
+  httpScanning = true;
+  try {
+    const ips = getSubnetIPs();
+    // Scan in batches of 50 to avoid fd exhaustion
+    for (let i = 0; i < ips.length; i += 50) {
+      const batch = ips.slice(i, i + 50);
+      const results = await Promise.all(batch.map(pingHost));
+      for (const r of results) {
+        if (!r) continue;
+        const id = `${r.ip}:${r.tcp_port}`;
+        const isNew = !peers.has(id);
+        peers.set(id, {
+          device_name: r.device_name,
+          ip: r.ip,
+          tcp_port: r.tcp_port,
+          last_seen: Date.now(),
+        });
+        if (isNew) {
+          console.log(`  Found: ${r.device_name} (${r.ip})`);
+          broadcast();
+        }
+      }
+    }
+  } catch { /* scan error, ignore */ }
+  httpScanning = false;
+}
+
+// Run HTTP discovery scan every 5 seconds
+setInterval(httpDiscoveryScan, 5_000);
+// Also run immediately on start (after a short delay for server to be ready)
+setTimeout(httpDiscoveryScan, 1_000);
+
 // ──────────────────────────────────────────────────────────────────────────────
 // Start
 // ──────────────────────────────────────────────────────────────────────────────
@@ -567,12 +671,12 @@ server.listen(HTTP_PORT, () => {
   console.log('  ⇄  LAN File Transfer');
   console.log(`  Device:    ${deviceName}`);
   console.log(`  Local IP:  ${ip}`);
+  console.log(`  Discovery  HTTP scan (no firewall needed)`);
+  console.log(`  Discovery  UDP :${DISCOVERY_PORT} (fallback)`);
+  console.log(`  Transfer   TCP :${TRANSFER_PORT}`);
   console.log(`  UI:        http://localhost:${HTTP_PORT}`);
   console.log('');
 
-  // Check firewall on Windows
-  checkWindowsFirewall();
-
   // Auto-open browser
   const url = `http://localhost:${HTTP_PORT}`;
   if (process.platform === 'win32') exec(`start "" "${url}"`);