feat: add instbyte watch — real-time clipboard sync from any channel

Author: mohitgauniyal

bin/cli/watch.js

@@ -0,0 +1,124 @@
+"use strict";
+
+const { spawn }         = require("child_process");
+const os                = require("os");
+const { resolveServer } = require("./resolve");
+
+const argv = process.argv.slice(3);
+
+function parseArgs(argv) {
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key  = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--")) { flags[key] = next; i++; }
+      else flags[key] = true;
+    }
+  }
+  return flags;
+}
+
+// Write text to the system clipboard.
+// Falls back to printing the text if the clipboard tool is not found.
+function copyToClipboard(text) {
+  let cmd, args;
+  if (process.platform === "darwin") {
+    cmd = "pbcopy"; args = [];
+  } else if (process.platform === "win32") {
+    cmd = "clip"; args = [];
+  } else {
+    cmd = "xclip"; args = ["-sel", "c"];
+  }
+
+  const proc = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+  proc.on("error", () => process.stdout.write(text + "\n")); // fallback
+  proc.stdin.write(text, "utf-8");
+  proc.stdin.end();
+}
+
+function truncate(str, len) {
+  return str.length > len ? str.slice(0, len) + "…" : str;
+}
+
+function run() {
+  const flags = parseArgs(argv);
+
+  if (flags.help) {
+    console.log("Usage: instbyte watch [--channel <name>] [--server <url>] [--passphrase <pass>] [--output]");
+    process.exit(0);
+  }
+
+  const { url } = resolveServer(flags);
+  const channel    = flags.channel || "general";
+  const outputMode = !!flags.output;
+
+  // In --output mode, status messages go to stderr so stdout stays clean for piping
+  const status = outputMode
+    ? (msg) => process.stderr.write(msg + "\n")
+    : (msg) => process.stdout.write(msg + "\n");
+
+  const { io } = require("socket.io-client");
+
+  const socket = io(url, {
+    reconnection: true,
+    reconnectionDelay: 2000,
+    reconnectionDelayMax: 10000
+  });
+
+  let connected       = false;
+  let connectErrShown = false;
+  let stopping        = false;
+
+  socket.on("connect", () => {
+    socket.emit("join", os.userInfo().username);
+    status(connected
+      ? "Reconnected."
+      : `Watching ${channel} on ${url}... (Ctrl+C to stop)`
+    );
+    connected       = true;
+    connectErrShown = false;
+  });
+
+  socket.on("disconnect", () => {
+    if (stopping) return;
+    connected = false;
+    status("Reconnecting...");
+  });
+
+  socket.on("connect_error", () => {
+    if (!connectErrShown) {
+      status(`✗ Cannot connect to ${url}`);
+      status(`  Start a server with: npx instbyte`);
+      connectErrShown = true;
+    }
+  });
+
+  socket.on("new-item", (item) => {
+    if (item.channel !== channel) return;
+
+    if (item.type === "file") {
+      process.stdout.write(`📎 File: ${url}/uploads/${item.filename}\n`);
+      return;
+    }
+
+    if (item.type === "text") {
+      if (outputMode) {
+        process.stdout.write(item.content + "\n");
+      } else {
+        copyToClipboard(item.content);
+        process.stdout.write(`✓ Copied: "${truncate(item.content, 60)}"\n`);
+      }
+    }
+  });
+
+  process.on("SIGINT", () => {
+    stopping = true;
+    socket.disconnect();
+    process.stdout.write("\nStopped watching.\n");
+    process.exit(0);
+  });
+}
+
+run();

nodemon.json

@@ -0,0 +1,3 @@
+{
+  "ignore": ["instbyte-data/", "uploads/"]
+}

package-lock.json

@@ -45,6 +45,7 @@
     "multer": "^2.0.2",
     "sharp": "^0.33.2",
     "socket.io": "^4.6.1",
+    "socket.io-client": "^4.6.1",
     "sqlite3": "^5.1.6"
   },
   "devDependencies": {

package.json

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest'
+
+// Inlined from bin/cli/send.js — tests the binary stdin guard logic
+function isBinary(buf) {
+  const limit = Math.min(buf.length, 512);
+  for (let i = 0; i < limit; i++) {
+    if (buf[i] === 0) return true;
+  }
+  return false;
+}
+
+describe('isBinary', () => {
+  it('returns false for empty buffer', () => {
+    expect(isBinary(Buffer.alloc(0))).toBe(false)
+  })
+
+  it('returns false for plain UTF-8 text', () => {
+    expect(isBinary(Buffer.from('hello from terminal\n'))).toBe(false)
+  })
+
+  it('returns false for multiline text', () => {
+    expect(isBinary(Buffer.from('line one\nline two\nline three\n'))).toBe(false)
+  })
+
+  it('returns true when null byte is at the start', () => {
+    expect(isBinary(Buffer.from([0x00, 0x01, 0x02]))).toBe(true)
+  })
+
+  it('returns true when null byte is within the first 512 bytes', () => {
+    const buf = Buffer.alloc(100, 0x41) // 'A' * 100
+    buf[50] = 0x00
+    expect(isBinary(buf)).toBe(true)
+  })
+
+  it('returns false when null byte is beyond the 512-byte sample window', () => {
+    const buf = Buffer.alloc(600, 0x41) // 'A' * 600
+    buf[513] = 0x00                     // null byte outside the check window
+    expect(isBinary(buf)).toBe(false)
+  })
+
+  it('returns true for a buffer that starts with common binary magic bytes', () => {
+    // ZIP magic number — PK\x03\x04
+    const zip = Buffer.from([0x50, 0x4B, 0x03, 0x04, 0x00])
+    expect(isBinary(zip)).toBe(true)
+  })
+
+  it('returns false for JSON content', () => {
+    const json = Buffer.from(JSON.stringify({ key: 'value', num: 42 }))
+    expect(isBinary(json)).toBe(false)
+  })
+})