@involvex/syncstuff-cli 0.0.4 → 0.0.6

package/dist/cli.js

@@ -9691,6 +9691,7 @@ async function showHelp(command) {
 `) + "  " + source_default.green("devices") + `             List all your connected devices
 ` + "  " + source_default.green("device --list") + `       List available devices
 ` + "  " + source_default.green("device <id>") + `         Connect to a specific device
+` + "  " + source_default.green("scan") + `                Scan local network for devices
 ` + "  " + source_default.green("transfer <file>") + `     Transfer a file to a device
 
 ` + source_default.bold(`General:
@@ -9787,7 +9788,26 @@ Show CLI version.
 ${source_default.bold("Usage:")}
   syncstuff version
   syncstuff --version
-  syncstuff -v`
+  syncstuff -v`,
+    scan: `${source_default.cyan.bold("scan")}
+
+Scan local network for SyncStuff devices.
+
+${source_default.bold("Usage:")}
+  syncstuff scan [options]
+
+${source_default.bold("Options:")}
+  --timeout N    Set scan timeout in seconds (default: 10)
+  --watch, -w    Continuously scan and show new devices
+
+${source_default.bold("Description:")}
+  Discovers SyncStuff devices on your local network using UDP broadcast.
+  This works without requiring cloud authentication.
+
+${source_default.bold("Examples:")}
+  syncstuff scan              Scan for 10 seconds
+  syncstuff scan --timeout 30 Scan for 30 seconds
+  syncstuff scan --watch      Continuously monitor for devices`
   };
 });
 
@@ -20411,7 +20431,7 @@ var init_RemoveFileError = __esm(() => {
 
 // ../../node_modules/.bun/@inquirer+external-editor@2.0.2+cda980ff03d0f389/node_modules/@inquirer/external-editor/dist/index.js
 import { spawn, spawnSync } from "child_process";
-import { readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { readFileSync as readFileSync3, unlinkSync, writeFileSync } from "fs";
 import path from "node:path";
 import os2 from "node:os";
 import { randomUUID } from "node:crypto";
@@ -20527,7 +20547,7 @@ class ExternalEditor {
   }
   readTemporaryFile() {
     try {
-      const tempFileBuffer = readFileSync2(this.tempFile);
+      const tempFileBuffer = readFileSync3(this.tempFile);
       if (tempFileBuffer.length === 0) {
         this.text = "";
       } else {
@@ -30801,9 +30821,9 @@ var init_dist16 = __esm(() => {
 });
 
 // src/utils/config.ts
-import { mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { mkdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function ensureConfigDir() {
   try {
     mkdirSync(CONFIG_DIR, { recursive: true });
@@ -30812,7 +30832,7 @@ function ensureConfigDir() {
 function readConfig() {
   ensureConfigDir();
   try {
-    const content = readFileSync3(CONFIG_FILE, "utf-8");
+    const content = readFileSync4(CONFIG_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -30824,8 +30844,8 @@ function writeConfig(config) {
 }
 var CONFIG_DIR, CONFIG_FILE;
 var init_config = __esm(() => {
-  CONFIG_DIR = join2(homedir(), ".syncstuff");
-  CONFIG_FILE = join2(CONFIG_DIR, "config.json");
+  CONFIG_DIR = join3(homedir(), ".syncstuff");
+  CONFIG_FILE = join3(CONFIG_DIR, "config.json");
 });
 
 // src/utils/api-client.ts
@@ -31079,8 +31099,17 @@ var exports_devices = {};
 __export(exports_devices, {
   listDevices: () => listDevices
 });
-async function listDevices(ctx) {
-  printHeader();
+async function listDevices(args, ctx) {
+  const isLoop = args.includes("--loop") || args.includes("-l");
+  debugLog(ctx, "Devices command", { loop: isLoop });
+  if (isLoop) {
+    await loopDevices(ctx);
+  } else {
+    printHeader();
+    await fetchAndDisplayDevices(ctx);
+  }
+}
+async function fetchAndDisplayDevices(ctx) {
   debugLog(ctx, "Fetching devices list");
   if (!apiClient.isAuthenticated()) {
     error2("You are not logged in. Please run 'syncstuff login' first.");
@@ -31096,7 +31125,7 @@ async function listDevices(ctx) {
       if (response.data.length === 0) {
         info2("No devices found. Connect a device to get started.");
         printSeparator();
-        return;
+        return true;
       }
       const tableData = response.data.map((device) => [
         device.id.substring(0, 8) + "...",
@@ -31118,6 +31147,7 @@ async function listDevices(ctx) {
       printSeparator();
       success2(`Found ${response.data.length} device(s)`);
       printSeparator();
+      return true;
     } else {
       spinner.fail("Failed to fetch devices");
       if (response.error?.includes("404") || response.error?.includes("Not found")) {
@@ -31126,13 +31156,39 @@ async function listDevices(ctx) {
       } else {
         error2(response.error || "Unknown error");
       }
+      return false;
     }
   } catch (err) {
     spinner.fail("Error fetching devices");
     error2(`Error: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
+    return false;
   }
 }
+async function loopDevices(ctx) {
+  const REFRESH_INTERVAL = 5000;
+  console.clear();
+  printHeader();
+  console.log(source_default.cyan("Loop mode enabled. Press Ctrl+C to exit."));
+  console.log(source_default.gray(`Refreshing every ${REFRESH_INTERVAL / 1000} seconds...
+`));
+  process.on("SIGINT", () => {
+    console.log(`
+`);
+    info2("Loop stopped by user");
+    process.exit(0);
+  });
+  await fetchAndDisplayDevices(ctx);
+  const interval = setInterval(async () => {
+    console.clear();
+    printHeader();
+    console.log(source_default.cyan("Loop mode enabled. Press Ctrl+C to exit."));
+    console.log(source_default.gray(`Last refresh: ${new Date().toLocaleTimeString()}
+`));
+    await fetchAndDisplayDevices(ctx);
+  }, REFRESH_INTERVAL);
+  await new Promise(() => {});
+  clearInterval(interval);
+}
 var init_devices = __esm(() => {
   init_source();
   init_api_client();
@@ -31460,6 +31516,224 @@ var init_transfer = __esm(() => {
   init_ui();
 });
 
+// src/utils/network.ts
+import { createSocket } from "dgram";
+import { networkInterfaces } from "os";
+
+class NetworkScanner {
+  socket = null;
+  getLocalIPs() {
+    const interfaces = networkInterfaces();
+    const ips = [];
+    for (const name of Object.keys(interfaces)) {
+      const iface = interfaces[name];
+      if (!iface)
+        continue;
+      for (const addr of iface) {
+        if (addr.family === "IPv4" && !addr.internal) {
+          ips.push(addr.address);
+        }
+      }
+    }
+    return ips;
+  }
+  async scan(timeout = 1e4) {
+    return new Promise((resolve2) => {
+      const devices = [];
+      const seenIds = new Set;
+      try {
+        this.socket = createSocket({ type: "udp4", reuseAddr: true });
+        this.socket.on("error", (err) => {
+          console.error("Scanner error:", err.message);
+          this.cleanup();
+          resolve2(devices);
+        });
+        this.socket.on("message", (msg, rinfo) => {
+          try {
+            const data = JSON.parse(msg.toString());
+            if (data.service === "syncstuff" && data.deviceId) {
+              if (!seenIds.has(data.deviceId)) {
+                seenIds.add(data.deviceId);
+                devices.push({
+                  id: data.deviceId,
+                  name: data.deviceName || "Unknown Device",
+                  platform: data.platform || "unknown",
+                  ip: rinfo.address,
+                  port: data.port || 8080,
+                  version: data.version || "1.0.0"
+                });
+              }
+            }
+          } catch {}
+        });
+        this.socket.bind(0, () => {
+          this.socket?.setBroadcast(true);
+          const discoveryMessage = JSON.stringify({
+            service: "syncstuff",
+            action: "discover",
+            timestamp: Date.now()
+          });
+          const localIPs = this.getLocalIPs();
+          for (const ip of localIPs) {
+            const parts = ip.split(".");
+            parts[3] = "255";
+            const broadcastAddr = parts.join(".");
+            this.socket?.send(discoveryMessage, 0, discoveryMessage.length, SYNCSTUFF_PORT, broadcastAddr);
+          }
+          this.socket?.send(discoveryMessage, 0, discoveryMessage.length, SYNCSTUFF_PORT, "224.0.0.251");
+        });
+        setTimeout(() => {
+          this.cleanup();
+          resolve2(devices);
+        }, timeout);
+      } catch (error3) {
+        console.error("Failed to start scanner:", error3);
+        resolve2(devices);
+      }
+    });
+  }
+  cleanup() {
+    if (this.socket) {
+      try {
+        this.socket.close();
+      } catch {}
+      this.socket = null;
+    }
+  }
+  async sendTo(ip, port, message) {
+    return new Promise((resolve2, reject) => {
+      const socket = createSocket("udp4");
+      const data = JSON.stringify(message);
+      socket.send(data, 0, data.length, port, ip, (err) => {
+        socket.close();
+        if (err) {
+          reject(err);
+        } else {
+          resolve2();
+        }
+      });
+    });
+  }
+}
+var SYNCSTUFF_PORT = 5353, networkScanner;
+var init_network = __esm(() => {
+  networkScanner = new NetworkScanner;
+});
+
+// src/cli/commands/scan.ts
+var exports_scan = {};
+__export(exports_scan, {
+  scanLocal: () => scanLocal
+});
+async function scanLocal(args, ctx) {
+  const timeout = args.includes("--timeout") ? parseInt(args[args.indexOf("--timeout") + 1] || "10", 10) : 10;
+  const continuous = args.includes("--watch") || args.includes("-w");
+  printHeader();
+  debugLog(ctx, "Scan command", { timeout, continuous });
+  console.log(source_default.cyan("Scanning local network for SyncStuff devices..."));
+  console.log(source_default.gray(`Timeout: ${timeout} seconds. Use --timeout N to change.
+`));
+  if (continuous) {
+    await continuousScan(ctx, timeout);
+  } else {
+    await singleScan(ctx, timeout);
+  }
+}
+async function singleScan(ctx, timeout) {
+  const spinner = createSpinner("Scanning network...");
+  spinner.start();
+  try {
+    const devices = await networkScanner.scan(timeout * 1000);
+    if (devices.length === 0) {
+      spinner.info("No devices found on local network");
+      printSeparator();
+      info2("Make sure SyncStuff is running on other devices on this network.");
+      info2("Devices must be on the same local network (Wi-Fi or Ethernet).");
+      printSeparator();
+      return;
+    }
+    spinner.succeed(`Found ${devices.length} device(s) on local network`);
+    printSeparator();
+    displayDevices(devices);
+    printSeparator();
+    success2(`Scan complete. Found ${devices.length} device(s).`);
+    info2("Use 'syncstuff transfer <file>' to send files to these devices.");
+    printSeparator();
+  } catch (err) {
+    spinner.fail("Network scan failed");
+    error2(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    debugLog(ctx, "Scan error", { error: err });
+  }
+}
+async function continuousScan(ctx, timeout) {
+  console.log(source_default.cyan(`Watch mode enabled. Press Ctrl+C to exit.
+`));
+  process.on("SIGINT", () => {
+    console.log(`
+`);
+    info2("Scan stopped by user");
+    process.exit(0);
+  });
+  const knownDevices = new Map;
+  while (true) {
+    const spinner = createSpinner("Scanning...");
+    spinner.start();
+    try {
+      const devices = await networkScanner.scan(timeout * 1000);
+      for (const device2 of devices) {
+        if (!knownDevices.has(device2.id)) {
+          spinner.succeed(`New device found: ${source_default.cyan(device2.name)}`);
+          knownDevices.set(device2.id, device2);
+        }
+      }
+      for (const [id, device2] of knownDevices.entries()) {
+        if (!devices.find((d) => d.id === id)) {
+          warning2(`Device lost: ${device2.name}`);
+          knownDevices.delete(id);
+        }
+      }
+      if (devices.length > 0) {
+        spinner.stop();
+        console.clear();
+        printHeader();
+        console.log(source_default.cyan(`Watch mode - ${new Date().toLocaleTimeString()} - Press Ctrl+C to exit.
+`));
+        displayDevices(devices);
+      } else {
+        spinner.info("No devices found. Retrying...");
+      }
+    } catch (err) {
+      spinner.fail("Scan error, retrying...");
+      debugLog(ctx, "Watch scan error", { error: err });
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 3000));
+  }
+}
+function displayDevices(devices) {
+  const tableData = devices.map((device2) => [
+    device2.id.substring(0, 8) + "...",
+    device2.name,
+    device2.platform,
+    `${device2.ip}:${device2.port}`,
+    device2.version,
+    source_default.green("Available")
+  ]);
+  const table = createTable(tableData, [
+    "ID",
+    "Name",
+    "Platform",
+    "Address",
+    "Version",
+    "Status"
+  ]);
+  console.log(table);
+}
+var init_scan = __esm(() => {
+  init_source();
+  init_network();
+  init_ui();
+});
+
 // src/core.ts
 var DebugMode;
 var init_core = __esm(() => {
@@ -31473,14 +31747,14 @@ var exports_version = {};
 __export(exports_version, {
   showversion: () => showversion
 });
-import { readFileSync as readFileSync4 } from "fs";
-import { dirname, join as join3 } from "path";
-import { fileURLToPath } from "url";
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function showversion() {
   printHeader();
   try {
-    const packagePath = join3(__dirname2, "../../../package.json");
-    const packageJson = JSON.parse(readFileSync4(packagePath, "utf-8"));
+    const packagePath = join4(__dirname3, "../../../package.json");
+    const packageJson = JSON.parse(readFileSync5(packagePath, "utf-8"));
     const version = packageJson.version;
     if (DebugMode.enabled === true) {
       console.log(source_default.yellow("Debug mode enabled"));
@@ -31498,29 +31772,79 @@ function showversion() {
     printSeparator();
   } catch {
     if (DebugMode.enabled === true) {
-      const packagePath = join3(__dirname2, "../../../package.json");
+      const packagePath = join4(__dirname3, "../../../package.json");
       console.log(source_default.yellow("Debug mode enabled"));
       console.log("Packagepath: " + packagePath);
       console.log(source_default.yellow("Version: 0.0.1 (unable to read package.json)"));
     }
-    console.log(source_default.yellow("Version: 0.0.1 (unable to read package.json)"));
   }
 }
-var __filename2, __dirname2;
+var __filename3, __dirname3;
 var init_version = __esm(() => {
   init_source();
   init_core();
   init_ui();
-  __filename2 = fileURLToPath(import.meta.url);
-  __dirname2 = dirname(__filename2);
+  __filename3 = fileURLToPath2(import.meta.url);
+  __dirname3 = dirname2(__filename3);
 });
 
 // src/cli/index.ts
 init_ui();
+
+// src/utils/update-checker.ts
+init_source();
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+async function checkForUpdates() {
+  try {
+    const packagePath = join2(__dirname2, "../../package.json");
+    const packageJson = JSON.parse(readFileSync2(packagePath, "utf-8"));
+    const currentVersion = packageJson.version;
+    const packageName = packageJson.name;
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(3000)
+    });
+    if (!response.ok) {
+      return;
+    }
+    const data = await response.json();
+    const latestVersion = data.version;
+    if (latestVersion && latestVersion !== currentVersion) {
+      const isNewer = compareVersions(latestVersion, currentVersion) > 0;
+      if (isNewer) {
+        console.log("");
+        console.log(source_default.yellow.bold("╭─────────────────────────────────────────╮"));
+        console.log(source_default.yellow.bold("│") + source_default.yellow("  Update available! ") + source_default.gray(`${currentVersion}`) + source_default.yellow(" → ") + source_default.green.bold(`${latestVersion}`) + source_default.yellow.bold("  │"));
+        console.log(source_default.yellow.bold("│") + source_default.cyan(`  Run: npm i -g ${packageName}`) + " ".repeat(7) + source_default.yellow.bold("│"));
+        console.log(source_default.yellow.bold("╰─────────────────────────────────────────╯"));
+        console.log("");
+      }
+    }
+  } catch {}
+}
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    const partA = partsA[i] || 0;
+    const partB = partsB[i] || 0;
+    if (partA !== partB) {
+      return partA - partB;
+    }
+  }
+  return 0;
+}
+
+// src/cli/index.ts
 async function run() {
   const args = process.argv.slice(2);
   const { command, flags, commandArgs } = parseArgs(args);
   const ctx = { debug: flags.debug };
+  checkForUpdates();
   debugLog(ctx, "Parsed arguments:", { command, flags, commandArgs });
   if (flags.help) {
     const { showHelp: showHelp2 } = await Promise.resolve().then(() => (init_help(), exports_help));
@@ -31554,7 +31878,7 @@ async function run() {
     case "devices":
       {
         const { listDevices: listDevices2 } = await Promise.resolve().then(() => (init_devices(), exports_devices));
-        await listDevices2(ctx);
+        await listDevices2(commandArgs, ctx);
       }
       break;
     case "device":
@@ -31569,6 +31893,12 @@ async function run() {
         await transferFile2(commandArgs[0], ctx);
       }
       break;
+    case "scan":
+      {
+        const { scanLocal: scanLocal2 } = await Promise.resolve().then(() => (init_scan(), exports_scan));
+        await scanLocal2(commandArgs, ctx);
+      }
+      break;
     case "help":
       {
         const { showHelp: showHelp2 } = await Promise.resolve().then(() => (init_help(), exports_help));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@involvex/syncstuff-cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "homepage": "https://syncstuff-web.involvex.workers.dev/",
   "sponsor": {

package/src/cli/commands/devices.ts

@@ -11,8 +11,31 @@ import {
   success,
 } from "../../utils/ui.js";
 
-export async function listDevices(ctx: CommandContext): Promise<void> {
-  printHeader();
+/**
+ * List devices command
+ * Options:
+ *   --loop    Continuously refresh devices until Ctrl+C
+ */
+export async function listDevices(
+  args: string[],
+  ctx: CommandContext,
+): Promise<void> {
+  const isLoop = args.includes("--loop") || args.includes("-l");
+
+  debugLog(ctx, "Devices command", { loop: isLoop });
+
+  if (isLoop) {
+    await loopDevices(ctx);
+  } else {
+    printHeader();
+    await fetchAndDisplayDevices(ctx);
+  }
+}
+
+/**
+ * Fetch and display devices once
+ */
+async function fetchAndDisplayDevices(ctx: CommandContext): Promise<boolean> {
   debugLog(ctx, "Fetching devices list");
 
   if (!apiClient.isAuthenticated()) {
@@ -33,7 +56,7 @@ export async function listDevices(ctx: CommandContext): Promise<void> {
       if (response.data.length === 0) {
         info("No devices found. Connect a device to get started.");
         printSeparator();
-        return;
+        return true;
       }
 
       const tableData = response.data.map(device => [
@@ -58,6 +81,7 @@ export async function listDevices(ctx: CommandContext): Promise<void> {
       printSeparator();
       success(`Found ${response.data.length} device(s)`);
       printSeparator();
+      return true;
     } else {
       spinner.fail("Failed to fetch devices");
       if (
@@ -69,10 +93,53 @@ export async function listDevices(ctx: CommandContext): Promise<void> {
       } else {
         error(response.error || "Unknown error");
       }
+      return false;
     }
   } catch (err) {
     spinner.fail("Error fetching devices");
     error(`Error: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
+    return false;
   }
 }
+
+/**
+ * Loop mode: continuously refresh devices
+ */
+async function loopDevices(ctx: CommandContext): Promise<void> {
+  const REFRESH_INTERVAL = 5000; // 5 seconds
+
+  console.clear();
+  printHeader();
+  console.log(chalk.cyan("Loop mode enabled. Press Ctrl+C to exit."));
+  console.log(
+    chalk.gray(`Refreshing every ${REFRESH_INTERVAL / 1000} seconds...\n`),
+  );
+
+  // Handle Ctrl+C gracefully
+  process.on("SIGINT", () => {
+    console.log("\n");
+    info("Loop stopped by user");
+    process.exit(0);
+  });
+
+  // Initial fetch
+  await fetchAndDisplayDevices(ctx);
+
+  // Set up refresh loop
+  const interval = setInterval(async () => {
+    console.clear();
+    printHeader();
+    console.log(chalk.cyan("Loop mode enabled. Press Ctrl+C to exit."));
+    console.log(
+      chalk.gray(`Last refresh: ${new Date().toLocaleTimeString()}\n`),
+    );
+    await fetchAndDisplayDevices(ctx);
+  }, REFRESH_INTERVAL);
+
+  // Keep the process running
+  await new Promise(() => {
+    // This promise never resolves - we wait for SIGINT
+  });
+
+  clearInterval(interval);
+}

package/src/cli/commands/help.ts

@@ -78,6 +78,26 @@ ${chalk.bold("Usage:")}
   syncstuff version
   syncstuff --version
   syncstuff -v`,
+
+  scan: `${chalk.cyan.bold("scan")}
+
+Scan local network for SyncStuff devices.
+
+${chalk.bold("Usage:")}
+  syncstuff scan [options]
+
+${chalk.bold("Options:")}
+  --timeout N    Set scan timeout in seconds (default: 10)
+  --watch, -w    Continuously scan and show new devices
+
+${chalk.bold("Description:")}
+  Discovers SyncStuff devices on your local network using UDP broadcast.
+  This works without requiring cloud authentication.
+
+${chalk.bold("Examples:")}
+  syncstuff scan              Scan for 10 seconds
+  syncstuff scan --timeout 30 Scan for 30 seconds
+  syncstuff scan --watch      Continuously monitor for devices`,
 };
 
 export async function showHelp(command?: string): Promise<void> {
@@ -120,6 +140,9 @@ export async function showHelp(command?: string): Promise<void> {
       chalk.green("device <id>") +
       "         Connect to a specific device\n" +
       "  " +
+      chalk.green("scan") +
+      "                Scan local network for devices\n" +
+      "  " +
       chalk.green("transfer <file>") +
       "     Transfer a file to a device\n\n" +
       chalk.bold("General:\n") +

package/src/cli/commands/scan.ts

@@ -0,0 +1,156 @@
+import chalk from "chalk";
+import { debugLog, type CommandContext } from "../../utils/context.js";
+import { networkScanner, type LocalDevice } from "../../utils/network.js";
+import {
+  createSpinner,
+  createTable,
+  error,
+  info,
+  printHeader,
+  printSeparator,
+  success,
+  warning,
+} from "../../utils/ui.js";
+
+/**
+ * Scan local network for SyncStuff devices
+ * This works without cloud authentication
+ */
+export async function scanLocal(
+  args: string[],
+  ctx: CommandContext,
+): Promise<void> {
+  const timeout = args.includes("--timeout")
+    ? parseInt(args[args.indexOf("--timeout") + 1] || "10", 10)
+    : 10;
+  const continuous = args.includes("--watch") || args.includes("-w");
+
+  printHeader();
+  debugLog(ctx, "Scan command", { timeout, continuous });
+
+  console.log(chalk.cyan("Scanning local network for SyncStuff devices..."));
+  console.log(
+    chalk.gray(`Timeout: ${timeout} seconds. Use --timeout N to change.\n`),
+  );
+
+  if (continuous) {
+    await continuousScan(ctx, timeout);
+  } else {
+    await singleScan(ctx, timeout);
+  }
+}
+
+async function singleScan(ctx: CommandContext, timeout: number): Promise<void> {
+  const spinner = createSpinner("Scanning network...");
+  spinner.start();
+
+  try {
+    const devices = await networkScanner.scan(timeout * 1000);
+
+    if (devices.length === 0) {
+      spinner.info("No devices found on local network");
+      printSeparator();
+      info("Make sure SyncStuff is running on other devices on this network.");
+      info("Devices must be on the same local network (Wi-Fi or Ethernet).");
+      printSeparator();
+      return;
+    }
+
+    spinner.succeed(`Found ${devices.length} device(s) on local network`);
+    printSeparator();
+
+    displayDevices(devices);
+
+    printSeparator();
+    success(`Scan complete. Found ${devices.length} device(s).`);
+    info("Use 'syncstuff transfer <file>' to send files to these devices.");
+    printSeparator();
+  } catch (err) {
+    spinner.fail("Network scan failed");
+    error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    debugLog(ctx, "Scan error", { error: err });
+  }
+}
+
+async function continuousScan(
+  ctx: CommandContext,
+  timeout: number,
+): Promise<void> {
+  console.log(chalk.cyan("Watch mode enabled. Press Ctrl+C to exit.\n"));
+
+  // Handle Ctrl+C gracefully
+  process.on("SIGINT", () => {
+    console.log("\n");
+    info("Scan stopped by user");
+    process.exit(0);
+  });
+
+  const knownDevices = new Map<string, LocalDevice>();
+
+  while (true) {
+    const spinner = createSpinner("Scanning...");
+    spinner.start();
+
+    try {
+      const devices = await networkScanner.scan(timeout * 1000);
+
+      // Check for new devices
+      for (const device of devices) {
+        if (!knownDevices.has(device.id)) {
+          spinner.succeed(`New device found: ${chalk.cyan(device.name)}`);
+          knownDevices.set(device.id, device);
+        }
+      }
+
+      // Check for lost devices
+      for (const [id, device] of knownDevices.entries()) {
+        if (!devices.find(d => d.id === id)) {
+          warning(`Device lost: ${device.name}`);
+          knownDevices.delete(id);
+        }
+      }
+
+      if (devices.length > 0) {
+        spinner.stop();
+        console.clear();
+        printHeader();
+        console.log(
+          chalk.cyan(
+            `Watch mode - ${new Date().toLocaleTimeString()} - Press Ctrl+C to exit.\n`,
+          ),
+        );
+        displayDevices(devices);
+      } else {
+        spinner.info("No devices found. Retrying...");
+      }
+    } catch (err) {
+      spinner.fail("Scan error, retrying...");
+      debugLog(ctx, "Watch scan error", { error: err });
+    }
+
+    // Wait before next scan
+    await new Promise(resolve => setTimeout(resolve, 3000));
+  }
+}
+
+function displayDevices(devices: LocalDevice[]): void {
+  const tableData = devices.map(device => [
+    device.id.substring(0, 8) + "...",
+    device.name,
+    device.platform,
+    `${device.ip}:${device.port}`,
+    device.version,
+    chalk.green("Available"),
+  ]);
+
+  const table = createTable(tableData, [
+    "ID",
+    "Name",
+    "Platform",
+    "Address",
+    "Version",
+    "Status",
+  ]);
+
+  console.log(table);
+}

package/src/cli/commands/version.ts

@@ -43,6 +43,5 @@ export function showversion() {
       console.log("Packagepath: " + packagePath);
       console.log(chalk.yellow("Version: 0.0.1 (unable to read package.json)"));
     }
-    console.log(chalk.yellow("Version: 0.0.1 (unable to read package.json)"));
   }
 }

package/src/cli/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { debugLog, parseArgs, type CommandContext } from "../utils/context.js";
 import { printHeader } from "../utils/ui.js";
+import { checkForUpdates } from "../utils/update-checker.js";
 
 export async function run() {
   const args = process.argv.slice(2);
@@ -8,6 +9,9 @@ export async function run() {
 
   const ctx: CommandContext = { debug: flags.debug };
 
+  // Check for updates (non-blocking)
+  checkForUpdates();
+
   // Debug mode: log parsed arguments
   debugLog(ctx, "Parsed arguments:", { command, flags, commandArgs });
 
@@ -47,7 +51,7 @@ export async function run() {
     case "devices":
       {
         const { listDevices } = await import("./commands/devices.js");
-        await listDevices(ctx);
+        await listDevices(commandArgs, ctx);
       }
       break;
     case "device":
@@ -62,6 +66,12 @@ export async function run() {
         await transferFile(commandArgs[0], ctx);
       }
       break;
+    case "scan":
+      {
+        const { scanLocal } = await import("./commands/scan.js");
+        await scanLocal(commandArgs, ctx);
+      }
+      break;
     case "help":
       {
         const { showHelp } = await import("./commands/help.js");

package/src/utils/network.ts

@@ -0,0 +1,162 @@
+import { createSocket, type Socket } from "dgram";
+import { networkInterfaces } from "os";
+
+export interface LocalDevice {
+  id: string;
+  name: string;
+  platform: string;
+  ip: string;
+  port: number;
+  version: string;
+}
+
+const SYNCSTUFF_PORT = 5353; // mDNS port
+
+/**
+ * Network scanner for discovering SyncStuff devices on local network
+ * Uses UDP multicast to find devices
+ */
+class NetworkScanner {
+  private socket: Socket | null = null;
+
+  /**
+   * Get local IP addresses
+   */
+  getLocalIPs(): string[] {
+    const interfaces = networkInterfaces();
+    const ips: string[] = [];
+
+    for (const name of Object.keys(interfaces)) {
+      const iface = interfaces[name];
+      if (!iface) continue;
+
+      for (const addr of iface) {
+        if (addr.family === "IPv4" && !addr.internal) {
+          ips.push(addr.address);
+        }
+      }
+    }
+
+    return ips;
+  }
+
+  /**
+   * Scan the local network for SyncStuff devices
+   * Uses UDP broadcast to discover devices
+   */
+  async scan(timeout = 10000): Promise<LocalDevice[]> {
+    return new Promise(resolve => {
+      const devices: LocalDevice[] = [];
+      const seenIds = new Set<string>();
+
+      try {
+        this.socket = createSocket({ type: "udp4", reuseAddr: true });
+
+        this.socket.on("error", err => {
+          console.error("Scanner error:", err.message);
+          this.cleanup();
+          resolve(devices);
+        });
+
+        this.socket.on("message", (msg, rinfo) => {
+          try {
+            const data = JSON.parse(msg.toString());
+
+            if (data.service === "syncstuff" && data.deviceId) {
+              if (!seenIds.has(data.deviceId)) {
+                seenIds.add(data.deviceId);
+                devices.push({
+                  id: data.deviceId,
+                  name: data.deviceName || "Unknown Device",
+                  platform: data.platform || "unknown",
+                  ip: rinfo.address,
+                  port: data.port || 8080,
+                  version: data.version || "1.0.0",
+                });
+              }
+            }
+          } catch {
+            // Ignore non-JSON messages
+          }
+        });
+
+        this.socket.bind(0, () => {
+          this.socket?.setBroadcast(true);
+
+          // Send discovery broadcast
+          const discoveryMessage = JSON.stringify({
+            service: "syncstuff",
+            action: "discover",
+            timestamp: Date.now(),
+          });
+
+          // Broadcast on local network
+          const localIPs = this.getLocalIPs();
+          for (const ip of localIPs) {
+            const parts = ip.split(".");
+            parts[3] = "255";
+            const broadcastAddr = parts.join(".");
+
+            this.socket?.send(
+              discoveryMessage,
+              0,
+              discoveryMessage.length,
+              SYNCSTUFF_PORT,
+              broadcastAddr,
+            );
+          }
+
+          // Also try mDNS multicast address
+          this.socket?.send(
+            discoveryMessage,
+            0,
+            discoveryMessage.length,
+            SYNCSTUFF_PORT,
+            "224.0.0.251",
+          );
+        });
+
+        // Cleanup after timeout
+        setTimeout(() => {
+          this.cleanup();
+          resolve(devices);
+        }, timeout);
+      } catch (error) {
+        console.error("Failed to start scanner:", error);
+        resolve(devices);
+      }
+    });
+  }
+
+  private cleanup(): void {
+    if (this.socket) {
+      try {
+        this.socket.close();
+      } catch {
+        // Ignore close errors
+      }
+      this.socket = null;
+    }
+  }
+
+  /**
+   * Send a message to a specific device
+   */
+  async sendTo(ip: string, port: number, message: object): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const socket = createSocket("udp4");
+      const data = JSON.stringify(message);
+
+      socket.send(data, 0, data.length, port, ip, err => {
+        socket.close();
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+}
+
+export const networkScanner = new NetworkScanner();

package/src/utils/update-checker.ts

@@ -0,0 +1,86 @@
+import chalk from "chalk";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Check if a newer version of the CLI is available on npm
+ */
+export async function checkForUpdates(): Promise<void> {
+  try {
+    // Get current version from package.json
+    const packagePath = join(__dirname, "../../package.json");
+    const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+    const currentVersion = packageJson.version;
+    const packageName = packageJson.name;
+
+    // Fetch latest version from npm registry
+    const response = await fetch(
+      `https://registry.npmjs.org/${packageName}/latest`,
+      {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(3000), // 3 second timeout
+      },
+    );
+
+    if (!response.ok) {
+      return; // Silently fail if npm check fails
+    }
+
+    const data = (await response.json()) as { version: string };
+    const latestVersion = data.version;
+
+    // Compare versions
+    if (latestVersion && latestVersion !== currentVersion) {
+      const isNewer = compareVersions(latestVersion, currentVersion) > 0;
+
+      if (isNewer) {
+        console.log("");
+        console.log(
+          chalk.yellow.bold("╭─────────────────────────────────────────╮"),
+        );
+        console.log(
+          chalk.yellow.bold("│") +
+            chalk.yellow("  Update available! ") +
+            chalk.gray(`${currentVersion}`) +
+            chalk.yellow(" → ") +
+            chalk.green.bold(`${latestVersion}`) +
+            chalk.yellow.bold("  │"),
+        );
+        console.log(
+          chalk.yellow.bold("│") +
+            chalk.cyan(`  Run: npm i -g ${packageName}`) +
+            " ".repeat(7) +
+            chalk.yellow.bold("│"),
+        );
+        console.log(
+          chalk.yellow.bold("╰─────────────────────────────────────────╯"),
+        );
+        console.log("");
+      }
+    }
+  } catch {
+    // Silently fail - update check is not critical
+  }
+}
+
+/**
+ * Compare two semantic versions
+ * Returns: positive if a > b, negative if a < b, 0 if equal
+ */
+function compareVersions(a: string, b: string): number {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const partA = partsA[i] || 0;
+    const partB = partsB[i] || 0;
+    if (partA !== partB) {
+      return partA - partB;
+    }
+  }
+  return 0;
+}