@involvex/syncstuff-cli 0.0.6 → 0.0.7

package/dist/cli.js

@@ -9807,7 +9807,21 @@ ${source_default.bold("Description:")}
 ${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`
+  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`
   };
 });
 
@@ -31614,6 +31628,33 @@ class NetworkScanner {
       });
     });
   }
+  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(() => {
@@ -31734,6 +31775,101 @@ var init_scan = __esm(() => {
   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(() => {
@@ -31899,6 +32035,12 @@ async function run() {
         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.6",
+  "version": "0.0.7",
   "type": "module",
   "homepage": "https://syncstuff-web.involvex.workers.dev/",
   "sponsor": {

package/src/cli/commands/help.ts

@@ -98,6 +98,21 @@ ${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> {

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

@@ -72,6 +72,12 @@ export async function run() {
         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

@@ -157,6 +157,51 @@ class NetworkScanner {
       });
     });
   }
+
+  /**
+   * 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();