iframer-cli 2.1.1 → 2.1.4

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,23 +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>");
+        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 {
-        const server = action === "start" ? args[1] || null : null;
-        const res = await fetch(`${getServer()}/proxy`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ server }),
-        });
-        const data = await res.json();
-        console.log(JSON.stringify(data, null, 2));
+        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);
+        }
+
+        // Foreground mode (both --foreground and plain start)
+        await runProxyDaemon();
+        break;
       }
       break;
     }

package/mcp-server.cjs

@@ -28388,171 +28388,43 @@ class StdioServerTransport {
 
 // src/mcp/server.ts
 import { readFileSync } from "fs";
-import { join } from "path";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 import { homedir } from "os";
-
-// src/proxy/home-proxy.ts
-import net from "net";
-var state = { server: null, port: 0, active: false };
-function handleSocks5(socket) {
-  socket.on("error", () => socket.destroy());
-  socket.once("data", (greeting) => {
-    if (greeting[0] !== 5) {
-      socket.destroy();
-      return;
+import { execFile } from "child_process";
+var BASE_URL = process.env.IFRAMER_URL || "https://api.iframer.sh";
+var CREDENTIALS_PATH = join(homedir(), ".iframer", "credentials.json");
+var PROXY_FILE = join(homedir(), ".iframer", "proxy.json");
+var _thisFile = fileURLToPath(import.meta.url);
+var CLI_PATH = _thisFile.endsWith(".cjs") ? join(dirname(_thisFile), "cli.js") : join(dirname(_thisFile), "../../bin/cli.js");
+function readProxyState() {
+  try {
+    const data = JSON.parse(readFileSync(PROXY_FILE, "utf8"));
+    try {
+      process.kill(data.pid, 0);
+      return { active: true, ...data };
+    } catch {
+      return { active: false };
     }
-    socket.write(Buffer.from([5, 0]));
-    socket.once("data", (req) => {
-      if (req[0] !== 5 || req[1] !== 1) {
-        socket.destroy();
+  } catch {
+    return { active: false };
+  }
+}
+function spawnCliProxy(cliArgs) {
+  return new Promise((resolve) => {
+    execFile(process.execPath, [CLI_PATH, ...cliArgs], { timeout: 25000 }, (err, stdout, stderr) => {
+      if (err) {
+        resolve({ ok: false, error: stderr || err.message });
         return;
       }
-      let host;
-      let port;
-      const addrType = req[3];
-      if (addrType === 1) {
-        host = `${req[4]}.${req[5]}.${req[6]}.${req[7]}`;
-        port = req.readUInt16BE(8);
-      } else if (addrType === 3) {
-        const len = req[4];
-        host = req.slice(5, 5 + len).toString();
-        port = req.readUInt16BE(5 + len);
-      } else if (addrType === 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;
+      try {
+        resolve({ ok: true, ...JSON.parse(stdout) });
+      } catch {
+        resolve({ ok: false, error: stdout || "no output from proxy daemon" });
       }
-      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());
-    });
-  });
-}
-function startHomeProxy(preferredPort = 0) {
-  return new Promise((resolve, reject) => {
-    if (state.active && state.server) {
-      resolve(state.port);
-      return;
-    }
-    const server = net.createServer(handleSocks5);
-    server.listen(preferredPort, "0.0.0.0", () => {
-      state.server = server;
-      state.port = server.address().port;
-      state.active = true;
-      resolve(state.port);
-    });
-    server.on("error", reject);
-  });
-}
-function stopHomeProxy() {
-  return new Promise((resolve) => {
-    if (!state.server) {
-      resolve();
-      return;
-    }
-    state.server.close(() => {
-      state.server = null;
-      state.active = false;
-      state.port = 0;
-      resolve();
     });
   });
 }
-function getHomeProxyInfo() {
-  return {
-    active: state.active,
-    port: state.port,
-    proxyUrl: state.active ? `socks5://host.docker.internal:${state.port}` : null
-  };
-}
-
-// src/proxy/tunnel-client.ts
-import net2 from "net";
-async function startTunnel(apiBaseUrl, authToken) {
-  const localSocksPort = await startHomeProxy();
-  const wsUrl = apiBaseUrl.replace(/^http/, "ws") + "/proxy/tunnel";
-  const ws = new globalThis.WebSocket(wsUrl);
-  return new Promise((resolve, reject) => {
-    const sockets = new Map;
-    let done = false;
-    const fail = (reason) => {
-      if (!done) {
-        done = true;
-        reject(new Error(reason));
-      }
-      ws.close();
-    };
-    const stop = () => {
-      ws.close();
-      sockets.forEach((s) => s.destroy());
-      sockets.clear();
-    };
-    ws.onopen = () => {
-      ws.send(JSON.stringify({ type: "auth", token: authToken }));
-    };
-    ws.onmessage = (event) => {
-      try {
-        const msg = JSON.parse(typeof event.data === "string" ? event.data : event.data.toString());
-        if (msg.type === "ready") {
-          if (!done) {
-            done = true;
-            resolve({ remotePort: msg.port, stop });
-          }
-          return;
-        }
-        if (msg.type === "open") {
-          const socket = net2.connect(localSocksPort, "127.0.0.1");
-          sockets.set(msg.id, socket);
-          socket.on("data", (data) => {
-            if (ws.readyState === 1) {
-              ws.send(JSON.stringify({ type: "data", id: msg.id, data: data.toString("base64") }));
-            }
-          });
-          socket.on("close", () => {
-            sockets.delete(msg.id);
-            if (ws.readyState === 1)
-              ws.send(JSON.stringify({ type: "close", id: msg.id }));
-          });
-          socket.on("error", () => socket.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 = (err) => fail(`WebSocket error: ${err?.message ?? "unknown"}`);
-    ws.onclose = () => {
-      sockets.forEach((s) => s.destroy());
-      sockets.clear();
-    };
-    setTimeout(() => fail("Tunnel setup timed out (10s)"), 1e4);
-  });
-}
-
-// src/mcp/server.ts
-var activeTunnel = null;
-var BASE_URL = process.env.IFRAMER_URL || "https://api.iframer.sh";
-var CREDENTIALS_PATH = join(homedir(), ".iframer", "credentials.json");
 var cachedToken = null;
 function loadToken() {
   if (cachedToken)
@@ -28883,49 +28755,41 @@ WHEN TO USE: Try this whenever a site shows a captcha or bot detection wall. The
 }, async ({ action }) => {
   try {
     if (action === "status") {
-      const info = getHomeProxyInfo();
+      const state = readProxyState();
       const apiProxy = await fetch(`${BASE_URL}/proxy`).then((r) => r.json()).catch(() => null);
       return { content: [{ type: "text", text: JSON.stringify({
-        homeProxy: info,
-        apiProxy: apiProxy?.proxy ?? "unknown",
-        apiProxySource: apiProxy?.source ?? "unknown"
+        daemon: state,
+        apiProxy: apiProxy?.proxy ?? null,
+        apiProxySource: apiProxy?.source ?? null
       }, null, 2) }] };
     }
     if (action === "start") {
-      const isLocal = BASE_URL.includes("localhost") || BASE_URL.includes("127.0.0.1");
-      let proxyUrl;
-      if (isLocal) {
-        const port = await startHomeProxy();
-        proxyUrl = `socks5://host.docker.internal:${port}`;
-      } else {
-        if (activeTunnel)
-          activeTunnel.stop();
-        const token = loadToken();
-        const tunnel = await startTunnel(BASE_URL, token);
-        activeTunnel = tunnel;
-        proxyUrl = `socks5://127.0.0.1:${tunnel.remotePort}`;
-      }
-      const res = await fetch(`${BASE_URL}/proxy`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ server: proxyUrl })
-      }).then((r) => r.json()).catch((e) => ({ ok: false, error: e.message }));
-      if (!res.ok)
-        return err(`Home proxy started but failed to configure API: ${res.error}`);
+      const existing = readProxyState();
+      if (existing.active && existing.proxyUrl) {
+        await apiPost("/proxy", { server: existing.proxyUrl }).catch(() => {});
+        await apiPost("/interactive/stop").catch(() => {});
+        return { content: [{ type: "text", text: "Home proxy already running. Session restarted." }] };
+      }
+      const result = await spawnCliProxy(["proxy", "start", "--daemon"]);
+      if (!result.ok)
+        return err(`Failed to start proxy daemon: ${result.error}`);
+      const state = readProxyState();
+      if (!state.active || !state.proxyUrl)
+        return err("Proxy daemon started but proxy.json not found");
+      await apiPost("/proxy", { server: state.proxyUrl }).catch(() => {});
       await apiPost("/interactive/stop").catch(() => {});
-      return { content: [{ type: "text", text: `Home proxy active. Session restarted. Browser traffic now exits through your Mac's home IP.` }] };
+      return { content: [{ type: "text", text: `Home proxy active. Session restarted. Browser traffic now exits through your home IP.` }] };
     }
     if (action === "stop") {
-      activeTunnel?.stop();
-      activeTunnel = null;
-      await stopHomeProxy();
-      await fetch(`${BASE_URL}/proxy`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ server: null })
-      }).catch(() => {});
-      await apiPost("/interactive/stop").catch(() => {});
-      return { content: [{ type: "text", text: "Home proxy stopped. Session restarted. Browser traffic will use the default proxy (IPRoyal) or no proxy." }] };
+      const state = readProxyState();
+      if (state.active && state.pid) {
+        try {
+          process.kill(state.pid, "SIGTERM");
+        } catch {}
+      }
+      await apiPost("/proxy", { server: null }).catch(() => {});
+      apiPost("/interactive/stop").catch(() => {});
+      return { content: [{ type: "text", text: "Home proxy stopped. Session will restart on next use." }] };
     }
     return err("Unknown action");
   } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iframer-cli",
-  "version": "2.1.1",
+  "version": "2.1.4",
   "description": "CLI for iframer — browser access for AI agents",
   "bin": {
     "iframer": "./cli.js"