@involvex/syncstuff-cli 0.0.5 → 0.0.7

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,40 @@ 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`,
+    listen: `${source_default.cyan.bold("listen")}
+
+Start listening for incoming file transfers.
+
+${source_default.bold("Usage:")}
+  syncstuff listen
+
+${source_default.bold("Description:")}
+  Starts a local HTTP server and advertises this CLI on the network.
+  Allows other SyncStuff devices (like the Android app) to discover
+  this computer and send files to it directly via local network.
+
+${source_default.bold("Examples:")}
+  syncstuff listen`
   };
 });
 
@@ -31496,6 +31530,346 @@ 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();
+        }
+      });
+    });
+  }
+  startAdvertising(deviceName, port, platform = "cli") {
+    const socket = createSocket({ type: "udp4", reuseAddr: true });
+    socket.bind(() => {
+      socket.setBroadcast(true);
+    });
+    const advertise = () => {
+      const message = JSON.stringify({
+        service: "syncstuff",
+        deviceId: "cli-device-" + Math.floor(Math.random() * 1e4),
+        deviceName,
+        platform,
+        port,
+        version: "0.0.6",
+        timestamp: Date.now()
+      });
+      const localIPs = this.getLocalIPs();
+      for (const ip of localIPs) {
+        const parts = ip.split(".");
+        parts[3] = "255";
+        const broadcastAddr = parts.join(".");
+        socket.send(message, 0, message.length, SYNCSTUFF_PORT, broadcastAddr);
+      }
+      socket.send(message, 0, message.length, SYNCSTUFF_PORT, "224.0.0.251");
+    };
+    advertise();
+    return setInterval(advertise, 3000);
+  }
+}
+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/cli/commands/listen.ts
+var exports_listen = {};
+__export(exports_listen, {
+  listen: () => listen
+});
+import { createServer } from "http";
+import { networkInterfaces as networkInterfaces2 } from "os";
+async function listen(_args, ctx) {
+  printHeader();
+  debugLog(ctx, "Starting listen command");
+  console.log(source_default.cyan("Starting SyncStuff CLI Listener..."));
+  console.log(source_default.gray(`This allows other devices to discover this CLI and send files directly.
+`));
+  const spinner = createSpinner("Initializing network listener...");
+  spinner.start();
+  try {
+    const server = createServer(handleRequest);
+    server.listen(PORT, "0.0.0.0", () => {
+      spinner.succeed(`HTTP Server running on port ${PORT}`);
+      const ips = getLocalIPs();
+      if (ips.length > 0) {
+        info2("Listening on:");
+        ips.forEach((ip) => {
+          console.log(`  http://${ip}:${PORT}`);
+        });
+      }
+      startAdvertising();
+    });
+    server.on("error", (err) => {
+      spinner.fail("Failed to start server");
+      error2(`Server error: ${err.message}`);
+      process.exit(1);
+    });
+  } catch (err) {
+    spinner.fail("Failed to start listener");
+    error2(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+function handleRequest(req, res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  if (req.method === "OPTIONS") {
+    res.writeHead(200);
+    res.end();
+    return;
+  }
+  if (req.method === "GET" && req.url === "/status") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "online", type: "cli", version: "0.0.6" }));
+    return;
+  }
+  if (req.method === "POST" && req.url === "/upload") {
+    info2(`
+Incoming transfer request from ${req.socket.remoteAddress}`);
+    let dataLength = 0;
+    req.on("data", (chunk) => {
+      dataLength += chunk.length;
+    });
+    req.on("end", () => {
+      success2(`Received ${dataLength} bytes`);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, message: "File received" }));
+    });
+    return;
+  }
+  res.writeHead(404);
+  res.end("Not Found");
+}
+function getLocalIPs() {
+  const nets = networkInterfaces2();
+  const results = [];
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name] || []) {
+      if (net.family === "IPv4" && !net.internal) {
+        results.push(net.address);
+      }
+    }
+  }
+  return results;
+}
+function startAdvertising() {
+  info2(`
+Advertising CLI on local network...`);
+  networkScanner.startAdvertising("SyncStuff CLI", PORT);
+  info2("Ready to receive files. Press Ctrl+C to stop.");
+}
+var PORT = 54321;
+var init_listen = __esm(() => {
+  init_source();
+  init_network();
+  init_ui();
+});
+
 // src/core.ts
 var DebugMode;
 var init_core = __esm(() => {
@@ -31655,6 +32029,18 @@ 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 "listen":
+      {
+        const { listen: listen2 } = await Promise.resolve().then(() => (init_listen(), exports_listen));
+        await listen2(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.5",
+  "version": "0.0.7",
   "type": "module",
   "homepage": "https://syncstuff-web.involvex.workers.dev/",
   "sponsor": {

package/src/cli/commands/help.ts

@@ -78,6 +78,41 @@ ${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`,
+
+  listen: `${chalk.cyan.bold("listen")}
+
+Start listening for incoming file transfers.
+
+${chalk.bold("Usage:")}
+  syncstuff listen
+
+${chalk.bold("Description:")}
+  Starts a local HTTP server and advertises this CLI on the network.
+  Allows other SyncStuff devices (like the Android app) to discover
+  this computer and send files to it directly via local network.
+
+${chalk.bold("Examples:")}
+  syncstuff listen`,
 };
 
 export async function showHelp(command?: string): Promise<void> {
@@ -120,6 +155,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/listen.ts

@@ -0,0 +1,142 @@
+import chalk from "chalk";
+import { createServer, type IncomingMessage, type ServerResponse } from "http";
+import { networkInterfaces } from "os";
+import { type CommandContext, debugLog } from "../../utils/context.js";
+import { networkScanner } from "../../utils/network.js"; // Added this line
+import {
+  createSpinner,
+  error,
+  info,
+  printHeader,
+  success,
+} from "../../utils/ui.js";
+
+const PORT = 54321; // Default port for SyncStuff CLI
+
+export async function listen(
+  _args: string[],
+  ctx: CommandContext,
+): Promise<void> {
+  printHeader();
+  debugLog(ctx, "Starting listen command");
+
+  console.log(chalk.cyan("Starting SyncStuff CLI Listener..."));
+  console.log(
+    chalk.gray(
+      "This allows other devices to discover this CLI and send files directly.\n",
+    ),
+  );
+
+  const spinner = createSpinner("Initializing network listener...");
+  spinner.start();
+
+  try {
+    // 1. Start HTTP Server
+    const server = createServer(handleRequest);
+
+    server.listen(PORT, "0.0.0.0", () => {
+      spinner.succeed(`HTTP Server running on port ${PORT}`);
+
+      const ips = getLocalIPs();
+      if (ips.length > 0) {
+        info("Listening on:");
+        ips.forEach(ip => {
+          console.log(`  http://${ip}:${PORT}`);
+        });
+      }
+
+      // 2. Start UDP Broadcast (Advertising)
+      startAdvertising();
+    });
+
+    server.on("error", err => {
+      spinner.fail("Failed to start server");
+      error(`Server error: ${err.message}`);
+      process.exit(1);
+    });
+  } catch (err) {
+    spinner.fail("Failed to start listener");
+    error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle incoming HTTP requests
+ */
+function handleRequest(req: IncomingMessage, res: ServerResponse) {
+  // CORS headers
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+  if (req.method === "OPTIONS") {
+    res.writeHead(200);
+    res.end();
+    return;
+  }
+
+  if (req.method === "GET" && req.url === "/status") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({ status: "online", type: "cli", version: "0.0.6" }),
+    );
+    return;
+  }
+
+  if (req.method === "POST" && req.url === "/upload") {
+    // Handle file upload
+    info(`\nIncoming transfer request from ${req.socket.remoteAddress}`);
+
+    // Minimal handler for now - just acknowledge
+    // In a full implementation, we'd parse multipart/form-data or raw stream
+    // and save to disk
+
+    let dataLength = 0;
+    req.on("data", chunk => {
+      dataLength += chunk.length;
+    });
+
+    req.on("end", () => {
+      success(`Received ${dataLength} bytes`);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, message: "File received" }));
+    });
+
+    return;
+  }
+
+  res.writeHead(404);
+  res.end("Not Found");
+}
+
+/**
+ * Get local IP addresses
+ */
+function getLocalIPs(): string[] {
+  const nets = networkInterfaces();
+  const results: string[] = [];
+
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name] || []) {
+      // Skip over non-IPv4 and internal (i.e. 127.0.0.1) addresses
+      if (net.family === "IPv4" && !net.internal) {
+        results.push(net.address);
+      }
+    }
+  }
+  return results;
+}
+
+/**
+ * Advertise presence via UDP
+ */
+function startAdvertising() {
+  info("\nAdvertising CLI on local network...");
+
+  // Start advertising
+  // We use a random ID for the CLI session for now
+  networkScanner.startAdvertising("SyncStuff CLI", PORT);
+
+  info("Ready to receive files. Press Ctrl+C to stop.");
+}

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/index.ts

@@ -66,6 +66,18 @@ 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 "listen":
+      {
+        const { listen } = await import("./commands/listen.js");
+        await listen(commandArgs, ctx);
+      }
+      break;
     case "help":
       {
         const { showHelp } = await import("./commands/help.js");

package/src/utils/network.ts

@@ -0,0 +1,207 @@
+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();
+        }
+      });
+    });
+  }
+
+  /**
+   * Start advertising this device on the local network
+   */
+  startAdvertising(
+    deviceName: string,
+    port: number,
+    platform = "cli",
+  ): NodeJS.Timer {
+    const socket = createSocket({ type: "udp4", reuseAddr: true });
+
+    socket.bind(() => {
+      socket.setBroadcast(true);
+    });
+
+    const advertise = () => {
+      const message = JSON.stringify({
+        service: "syncstuff",
+        deviceId: "cli-device-" + Math.floor(Math.random() * 10000), // Simple random ID for CLI
+        deviceName,
+        platform,
+        port,
+        version: "0.0.6", // Should match package.json
+        timestamp: Date.now(),
+      });
+
+      const localIPs = this.getLocalIPs();
+      for (const ip of localIPs) {
+        const parts = ip.split(".");
+        parts[3] = "255";
+        const broadcastAddr = parts.join(".");
+
+        socket.send(message, 0, message.length, SYNCSTUFF_PORT, broadcastAddr);
+      }
+
+      // Also send to multicast group
+      socket.send(message, 0, message.length, SYNCSTUFF_PORT, "224.0.0.251");
+    };
+
+    // Advertise immediately
+    advertise();
+
+    // Then every 3 seconds
+    return setInterval(advertise, 3000);
+  }
+}
+
+export const networkScanner = new NetworkScanner();