iframer-cli 2.1.2 → 2.1.5

package/cli.js

@@ -7,10 +7,182 @@ const { execSync } = require("child_process");
 
 const readline = require("readline");
 
+const net = require("net");
+const { spawn } = require("child_process");
+
 const CONFIG_DIR = path.join(require("os").homedir(), ".iframer");
 const CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+const PROXY_FILE = path.join(CONFIG_DIR, "proxy.json");
 const DEFAULT_SERVER = "https://api.iframer.sh";
 
+// ─── SOCKS5 server ───────────────────────────────────────────────────────────
+
+function createSocks5Server() {
+  function handleClient(socket) {
+    socket.on("error", () => socket.destroy());
+    socket.once("data", (greeting) => {
+      if (greeting[0] !== 5) { socket.destroy(); return; }
+      socket.write(Buffer.from([5, 0]));
+      socket.once("data", (req) => {
+        if (req[0] !== 5 || req[1] !== 1) { socket.destroy(); return; }
+        let host, port;
+        const atype = req[3];
+        if (atype === 1) {
+          host = `${req[4]}.${req[5]}.${req[6]}.${req[7]}`;
+          port = req.readUInt16BE(8);
+        } else if (atype === 3) {
+          const len = req[4];
+          host = req.slice(5, 5 + len).toString();
+          port = req.readUInt16BE(5 + len);
+        } else if (atype === 4) {
+          const parts = [];
+          for (let i = 0; i < 16; i += 2) parts.push(req.readUInt16BE(4 + i).toString(16));
+          host = parts.join(":");
+          port = req.readUInt16BE(20);
+        } else { socket.destroy(); return; }
+        const target = net.connect(port, host, () => {
+          const reply = Buffer.alloc(10);
+          reply[0] = 5; reply[1] = 0; reply[2] = 0; reply[3] = 1;
+          socket.write(reply);
+          socket.pipe(target);
+          target.pipe(socket);
+        });
+        target.on("error", () => socket.destroy());
+        socket.on("close", () => target.destroy());
+      });
+    });
+  }
+  return net.createServer(handleClient);
+}
+
+function startSocks5(listenAll) {
+  return new Promise((resolve, reject) => {
+    const server = createSocks5Server();
+    server.listen(0, listenAll ? "0.0.0.0" : "127.0.0.1", () => {
+      resolve({ server, port: server.address().port });
+    });
+    server.on("error", reject);
+  });
+}
+
+// ─── WebSocket tunnel client ─────────────────────────────────────────────────
+
+function startWsTunnel(baseUrl, authToken, localSocksPort) {
+  return new Promise((resolve, reject) => {
+    if (!globalThis.WebSocket) {
+      reject(new Error("Node.js 22+ is required for the home proxy tunnel. Please upgrade Node."));
+      return;
+    }
+    const wsUrl = baseUrl.replace(/^http/, "ws") + "/proxy/tunnel";
+    const ws = new globalThis.WebSocket(wsUrl);
+    const sockets = new Map();
+    let done = false;
+
+    const fail = (reason) => {
+      if (!done) { done = true; reject(new Error(reason)); }
+      try { ws.close(); } catch {}
+    };
+
+    ws.onopen = () => {
+      try { ws.send(JSON.stringify({ type: "auth", token: authToken })); }
+      catch (e) { fail(`Auth failed: ${e.message}`); }
+    };
+
+    ws.onmessage = (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        if (msg.type === "ready") {
+          if (!done) { done = true; resolve({ remotePort: msg.port, ws, sockets }); }
+          return;
+        }
+        if (msg.type === "open") {
+          const sock = net.connect(localSocksPort, "127.0.0.1");
+          sockets.set(msg.id, sock);
+          sock.on("data", (d) => {
+            try { if (ws.readyState === 1) ws.send(JSON.stringify({ type: "data", id: msg.id, data: d.toString("base64") })); }
+            catch {}
+          });
+          sock.on("close", () => {
+            sockets.delete(msg.id);
+            try { if (ws.readyState === 1) ws.send(JSON.stringify({ type: "close", id: msg.id })); } catch {}
+          });
+          sock.on("error", () => sock.destroy());
+          return;
+        }
+        if (msg.type === "data") { sockets.get(msg.id)?.write(Buffer.from(msg.data, "base64")); return; }
+        if (msg.type === "close") { sockets.get(msg.id)?.destroy(); sockets.delete(msg.id); }
+      } catch {}
+    };
+
+    ws.onerror = (e) => fail(`WebSocket error: ${e?.message ?? "unknown"}`);
+    ws.onclose = (e) => {
+      sockets.forEach(s => s.destroy()); sockets.clear();
+      fail(`Tunnel closed (code=${e?.code ?? "?"}, reason=${e?.reason || "unknown"})`);
+    };
+
+    setTimeout(() => fail("Tunnel setup timed out (15s)"), 15000);
+  });
+}
+
+// ─── Proxy daemon ────────────────────────────────────────────────────────────
+
+function readProxyState() {
+  try {
+    const data = JSON.parse(fs.readFileSync(PROXY_FILE, "utf8"));
+    try { process.kill(data.pid, 0); return { active: true, ...data }; }
+    catch { try { fs.unlinkSync(PROXY_FILE); } catch {} return { active: false }; }
+  } catch { return { active: false }; }
+}
+
+async function runProxyDaemon() {
+  const server = getServer();
+  const isLocal = server.includes("localhost") || server.includes("127.0.0.1");
+
+  let socks, tunnel;
+  const cleanup = async () => {
+    try { socks?.server.close(); } catch {}
+    try { tunnel?.ws.close(); } catch {}
+    try {
+      const ac = new AbortController();
+      setTimeout(() => ac.abort(), 3000);
+      await fetch(`${server}/proxy`, {
+        method: "POST", headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ server: null }),
+        signal: ac.signal,
+      });
+    } catch {}
+    try { fs.unlinkSync(PROXY_FILE); } catch {}
+  };
+
+  try {
+    socks = await startSocks5(true); // listen on 0.0.0.0 so Docker can reach it
+
+    let proxyUrl;
+    if (isLocal) {
+      proxyUrl = `socks5://host.docker.internal:${socks.port}`;
+    } else {
+      const token = loadToken();
+      tunnel = await startWsTunnel(server, token, socks.port);
+      proxyUrl = `socks5://127.0.0.1:${tunnel.remotePort}`;
+    }
+
+    await fetch(`${server}/proxy`, {
+      method: "POST", headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ server: proxyUrl }),
+    });
+
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(PROXY_FILE, JSON.stringify({ pid: process.pid, proxyUrl, startedAt: new Date().toISOString() }, null, 2));
+
+    await new Promise((resolve) => {
+      process.once("SIGTERM", resolve);
+      process.once("SIGINT", resolve);
+    });
+  } finally {
+    await cleanup();
+  }
+}
+
 function getServer() {
   return process.env.IFRAMER_URL || DEFAULT_SERVER;
 }
@@ -518,38 +690,51 @@ async function main() {
 
     case "proxy": {
       const action = args[0];
+      const isDaemon = args.includes("--daemon");
+      const isForeground = args.includes("--foreground");
+
       if (!action || !["start", "stop", "status"].includes(action)) {
-        console.log("  Usage: iframer proxy <start|stop|status> [proxy-url]");
-        console.log("  Note:  'start' requires a proxy URL (e.g. socks5://host:port).");
-        console.log("         To use your home IP automatically, use the iframer MCP tool instead.");
+        console.log("  Usage: iframer proxy <start|stop|status>");
+        console.log("  start          Route browser traffic through your home IP (runs in foreground)");
+        console.log("  stop           Stop the home proxy");
+        console.log("  status         Check proxy status");
         break;
       }
+
       if (action === "status") {
-        const res = await fetch(`${getServer()}/proxy`);
-        const data = await res.json();
-        console.log(JSON.stringify(data, null, 2));
-      } else if (action === "stop") {
-        const res = await fetch(`${getServer()}/proxy`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ server: null }),
-        });
-        const data = await res.json();
-        console.log(JSON.stringify(data, null, 2));
-      } else if (action === "start") {
-        const proxyUrl = args[1];
-        if (!proxyUrl) {
-          console.error("  Error: 'proxy start' requires a proxy URL, e.g.: iframer proxy start socks5://host:port");
-          console.error("  To route through your home IP automatically, use the iframer MCP tool.");
+        console.log(JSON.stringify(readProxyState(), null, 2));
+        break;
+      }
+
+      if (action === "stop") {
+        const state = readProxyState();
+        if (!state.active) { console.log(JSON.stringify({ ok: true, message: "No proxy running" })); break; }
+        try { process.kill(state.pid, "SIGTERM"); } catch {}
+        await new Promise(r => setTimeout(r, 1500));
+        console.log(JSON.stringify({ ok: true, message: "Proxy stopped" }));
+        break;
+      }
+
+      if (action === "start") {
+        if (isDaemon) {
+          // Fork self with --foreground, detach, wait for proxy.json
+          const child = spawn(process.execPath, [__filename, "proxy", "start", "--foreground"], {
+            detached: true, stdio: "ignore", env: process.env,
+          });
+          child.unref();
+          const deadline = Date.now() + 20000;
+          while (Date.now() < deadline) {
+            await new Promise(r => setTimeout(r, 500));
+            const state = readProxyState();
+            if (state.active) { console.log(JSON.stringify({ ok: true, ...state })); process.exit(0); }
+          }
+          console.error(JSON.stringify({ ok: false, error: "Proxy daemon failed to start within 20s" }));
           process.exit(1);
         }
-        const res = await fetch(`${getServer()}/proxy`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ server: proxyUrl }),
-        });
-        const data = await res.json();
-        console.log(JSON.stringify(data, null, 2));
+
+        // Foreground mode (both --foreground and plain start)
+        await runProxyDaemon();
+        break;
       }
       break;
     }