@involvex/syncstuff-cli 0.0.5 → 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`
   };
 });
 
@@ -31496,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(() => {
@@ -31655,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.5",
+  "version": "0.0.6",
   "type": "module",
   "homepage": "https://syncstuff-web.involvex.workers.dev/",
   "sponsor": {

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

@@ -66,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();