itwillsync 1.2.1 → 1.3.1

package/dist/index.js

@@ -2766,7 +2766,7 @@ var require_websocket = __commonJS({
       }
       const defaultPort = isSecure ? 443 : 80;
       const key = randomBytes2(16).toString("base64");
-      const request = isSecure ? https.request : http.request;
+      const request2 = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -2843,12 +2843,12 @@ var require_websocket = __commonJS({
         if (opts.auth && !options.headers.authorization) {
           options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
         }
-        req = websocket._req = request(opts);
+        req = websocket._req = request2(opts);
         if (websocket._redirects) {
           websocket.emit("redirect", websocket.url, req);
         }
       } else {
-        req = websocket._req = request(opts);
+        req = websocket._req = request2(opts);
       }
       if (opts.timeout) {
         req.on("timeout", () => {
@@ -3683,6 +3683,14 @@ function ensureSpawnHelperPermissions() {
 }
 var PtyManager = class {
   ptyProcess;
+  _cols = 80;
+  _rows = 24;
+  get cols() {
+    return this._cols;
+  }
+  get rows() {
+    return this._rows;
+  }
   /** The process ID of the spawned PTY process. */
   pid;
   constructor(command, args) {
@@ -3725,6 +3733,8 @@ var PtyManager = class {
   resize(cols, rows) {
     try {
       this.ptyProcess.resize(cols, rows);
+      this._cols = cols;
+      this._rows = rows;
     } catch {
     }
   }
@@ -3929,7 +3939,7 @@ async function serveStaticFile(webClientPath, filePath, req, res) {
 var PING_INTERVAL_MS = 3e4;
 var SCROLLBACK_BUFFER_SIZE = 5e4;
 function createSyncServer(options) {
-  const { ptyManager, token, webClientPath, host, port } = options;
+  const { ptyManager, token, webClientPath, host, port, localTerminalOwnsResize = false } = options;
   const clients = /* @__PURE__ */ new Set();
   const aliveMap = /* @__PURE__ */ new WeakMap();
   let scrollbackBuffer = "";
@@ -3972,6 +3982,7 @@ function createSyncServer(options) {
     if (scrollbackBuffer.length > 0) {
       ws.send(JSON.stringify({ type: "data", data: scrollbackBuffer, seq }));
     }
+    ws.send(JSON.stringify({ type: "resize", cols: ptyManager.cols, rows: ptyManager.rows }));
     ws.on("pong", () => {
       aliveMap.set(ws, true);
     });
@@ -3981,7 +3992,9 @@ function createSyncServer(options) {
         if (message.type === "input" && typeof message.data === "string") {
           ptyManager.write(message.data);
         } else if (message.type === "resize" && typeof message.cols === "number" && typeof message.rows === "number") {
-          ptyManager.resize(message.cols, message.rows);
+          if (!localTerminalOwnsResize) {
+            ptyManager.resize(message.cols, message.rows);
+          }
         } else if (message.type === "resume" && typeof message.lastSeq === "number") {
           const missed = seq - message.lastSeq;
           if (missed > 0 && scrollbackBuffer.length > 0) {
@@ -4024,6 +4037,14 @@ function createSyncServer(options) {
       clients.clear();
       wssServer.close();
       httpServer.close();
+    },
+    broadcastResize(cols, rows) {
+      const msg = JSON.stringify({ type: "resize", cols, rows });
+      for (const client of clients) {
+        if (client.readyState === client.OPEN) {
+          client.send(msg);
+        }
+      }
     }
   };
 }
@@ -4149,8 +4170,233 @@ async function runSetupWizard() {
   return config;
 }
 
+// src/hub-client.ts
+import { spawn as spawn2 } from "child_process";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { request } from "http";
+var HUB_INTERNAL_PORT = 7963;
+var HUB_EXTERNAL_PORT = 7962;
+var SESSION_PORT_START = 7964;
+function getHubDir() {
+  return process.env.ITWILLSYNC_CONFIG_DIR || join4(homedir2(), ".itwillsync");
+}
+function getHubConfigPath() {
+  return join4(getHubDir(), "hub.json");
+}
+async function discoverHub() {
+  return new Promise((resolve) => {
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port: HUB_INTERNAL_PORT,
+        path: "/api/health",
+        method: "GET",
+        timeout: 2e3
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            resolve(json.status === "ok");
+          } catch {
+            resolve(false);
+          }
+        });
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.end();
+  });
+}
+async function spawnHub() {
+  const __dirname = dirname2(fileURLToPath2(import.meta.url));
+  const hubPath = join4(__dirname, "hub", "daemon.js");
+  return new Promise((resolve, reject) => {
+    const child = spawn2("node", [hubPath], {
+      detached: true,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: {
+        ...process.env,
+        // Pass config dir to hub
+        ITWILLSYNC_CONFIG_DIR: process.env.ITWILLSYNC_CONFIG_DIR || ""
+      }
+    });
+    child.unref();
+    let output = "";
+    const timeout = setTimeout(() => {
+      reject(new Error("Hub daemon startup timed out"));
+    }, 1e4);
+    child.stdout?.on("data", (data) => {
+      output += data.toString();
+      if (output.includes("hub:ready:")) {
+        clearTimeout(timeout);
+        child.stdout?.destroy();
+        resolve();
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`Failed to spawn hub daemon: ${err.message}`));
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timeout);
+      if (code !== null && code !== 0) {
+        reject(new Error(`Hub daemon exited with code ${code}`));
+      }
+    });
+  });
+}
+function getHubConfig() {
+  const configPath = getHubConfigPath();
+  if (!existsSync2(configPath)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function registerSession(registration) {
+  const body = JSON.stringify(registration);
+  return new Promise((resolve, reject) => {
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port: HUB_INTERNAL_PORT,
+        path: "/api/sessions",
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body)
+        },
+        timeout: 5e3
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            if (res.statusCode === 201 && json.session) {
+              resolve(json.session);
+            } else {
+              reject(new Error(`Registration failed: ${json.error || "Unknown error"}`));
+            }
+          } catch {
+            reject(new Error("Invalid response from hub"));
+          }
+        });
+      }
+    );
+    req.on("error", (err) => reject(new Error(`Failed to register with hub: ${err.message}`)));
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Registration request timed out"));
+    });
+    req.end(body);
+  });
+}
+async function unregisterSession(sessionId) {
+  return new Promise((resolve) => {
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port: HUB_INTERNAL_PORT,
+        path: `/api/sessions/${sessionId}`,
+        method: "DELETE",
+        timeout: 3e3
+      },
+      () => resolve()
+    );
+    req.on("error", () => resolve());
+    req.on("timeout", () => {
+      req.destroy();
+      resolve();
+    });
+    req.end();
+  });
+}
+async function listSessions() {
+  return new Promise((resolve) => {
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port: HUB_INTERNAL_PORT,
+        path: "/api/sessions",
+        method: "GET",
+        timeout: 3e3
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            resolve(json.sessions || []);
+          } catch {
+            resolve([]);
+          }
+        });
+      }
+    );
+    req.on("error", () => resolve([]));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve([]);
+    });
+    req.end();
+  });
+}
+function stopHub() {
+  const config = getHubConfig();
+  if (!config) return false;
+  try {
+    process.kill(config.pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function sendHeartbeat(sessionId) {
+  return new Promise((resolve) => {
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port: HUB_INTERNAL_PORT,
+        path: `/api/sessions/${sessionId}/heartbeat`,
+        method: "PUT",
+        timeout: 2e3
+      },
+      () => resolve()
+    );
+    req.on("error", () => resolve());
+    req.on("timeout", () => {
+      req.destroy();
+      resolve();
+    });
+    req.end();
+  });
+}
+
 // src/cli-options.ts
-var DEFAULT_PORT = 3456;
+var DEFAULT_PORT = SESSION_PORT_START;
 function parseArgs(argv) {
   const options = {
     port: DEFAULT_PORT,
@@ -4159,13 +4405,24 @@ function parseArgs(argv) {
     command: [],
     subcommand: null,
     tailscale: false,
-    local: false
+    local: false,
+    hubInfo: false,
+    hubStop: false,
+    hubStatus: false
   };
   const args = argv.slice(2);
   if (args.length > 0 && args[0] === "setup") {
     options.subcommand = "setup";
     return options;
   }
+  if (args.length > 0 && args[0] === "hub") {
+    const hubAction = args[1] || "info";
+    if (hubAction === "info") options.hubInfo = true;
+    else if (hubAction === "stop") options.hubStop = true;
+    else if (hubAction === "status") options.hubStatus = true;
+    else options.hubInfo = true;
+    return options;
+  }
   let i = 0;
   while (i < args.length) {
     const arg = args[i];
@@ -4187,6 +4444,15 @@ function parseArgs(argv) {
     } else if (arg === "--no-qr") {
       options.noQr = true;
       i++;
+    } else if (arg === "--hub-info") {
+      options.hubInfo = true;
+      i++;
+    } else if (arg === "--hub-stop") {
+      options.hubStop = true;
+      i++;
+    } else if (arg === "--hub-status") {
+      options.hubStatus = true;
+      i++;
     } else if (arg === "--help" || arg === "-h") {
       printHelp();
       process.exit(0);
@@ -4208,6 +4474,7 @@ Usage:
   itwillsync [options] -- <command> [args...]
   itwillsync [options] <command> [args...]
   itwillsync setup
+  itwillsync hub [info|stop|status]
 
 Examples:
   itwillsync -- claude
@@ -4216,9 +4483,14 @@ Examples:
   itwillsync --port 8080 -- claude
   itwillsync --tailscale -- claude
   itwillsync setup
+  itwillsync hub info
+  itwillsync hub stop
 
 Commands:
   setup              Run the setup wizard (configure networking mode)
+  hub info           Show dashboard URL, QR code, and hub status
+  hub stop           Stop the hub daemon and all sessions
+  hub status         List all active sessions
 
 Options:
   --port <number>    Port to listen on (default: ${DEFAULT_PORT})
@@ -4228,24 +4500,29 @@ Options:
   --no-qr            Don't display QR code
   -h, --help         Show this help
   -v, --version      Show version
+
+Hub Management:
+  --hub-info         Show dashboard URL, QR code, and hub status
+  --hub-stop         Stop the hub daemon and all sessions
+  --hub-status       List all active sessions
 `);
 }
 
 // src/index.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { join as join4, dirname as dirname2 } from "path";
-import { spawn as spawn2 } from "child_process";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { join as join5, dirname as dirname3 } from "path";
+import { spawn as spawn3 } from "child_process";
 function preventSleep() {
   try {
     if (process.platform === "darwin") {
-      const child = spawn2("caffeinate", ["-i", "-w", String(process.pid)], {
+      const child = spawn3("caffeinate", ["-i", "-w", String(process.pid)], {
         stdio: "ignore",
         detached: true
       });
       child.unref();
       return child;
     } else if (process.platform === "linux") {
-      return spawn2("systemd-inhibit", [
+      return spawn3("systemd-inhibit", [
         "--what=idle",
         "--who=itwillsync",
         "--why=Terminal sync session active",
@@ -4257,12 +4534,96 @@ function preventSleep() {
   }
   return null;
 }
+async function ensureHub() {
+  const hubRunning = await discoverHub();
+  if (hubRunning) {
+    return false;
+  }
+  try {
+    await spawnHub();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    return true;
+  } catch (err) {
+    console.warn(`
+  Warning: Could not start hub daemon: ${err.message}`);
+    console.warn("  Running in standalone mode (no dashboard).\n");
+    return true;
+  }
+}
+async function handleHubCommand(options) {
+  const hubConfig = getHubConfig();
+  const hubRunning = await discoverHub();
+  if (options.hubStop) {
+    if (!hubRunning || !hubConfig) {
+      console.log("\n  No hub daemon is running.\n");
+      return;
+    }
+    const stopped = stopHub();
+    if (stopped) {
+      console.log("\n  Hub daemon stopped.\n");
+    } else {
+      console.log("\n  Failed to stop hub daemon.\n");
+    }
+    return;
+  }
+  if (options.hubStatus) {
+    if (!hubRunning) {
+      console.log("\n  No hub daemon is running.\n");
+      return;
+    }
+    const sessions = await listSessions();
+    console.log(`
+  Hub is running. ${sessions.length} active session(s).
+`);
+    if (sessions.length > 0) {
+      for (const s of sessions) {
+        const uptime = Math.floor((Date.now() - s.connectedAt) / 6e4);
+        console.log(`    ${s.name || s.agent}  (${s.status}, ${uptime}m, port ${s.port})`);
+      }
+      console.log("");
+    }
+    return;
+  }
+  if (options.hubInfo) {
+    if (!hubRunning || !hubConfig) {
+      console.log("\n  No hub daemon is running.");
+      console.log("  Start a session with: itwillsync -- <agent>\n");
+      return;
+    }
+    let networkingMode = "local";
+    if (options.tailscale) {
+      networkingMode = "tailscale";
+    } else if (options.local) {
+      networkingMode = "local";
+    } else if (configExists()) {
+      networkingMode = loadConfig().networkingMode;
+    }
+    const ip = await resolveSessionIP(networkingMode, false);
+    const dashboardUrl = `http://${ip}:${HUB_EXTERNAL_PORT}?token=${hubConfig.masterToken}`;
+    displayQR(dashboardUrl);
+    console.log(`  Dashboard: ${dashboardUrl}`);
+    const sessions = await listSessions();
+    console.log(`  Sessions: ${sessions.length} active`);
+    if (sessions.length > 0) {
+      for (const s of sessions) {
+        const uptime = Math.floor((Date.now() - s.connectedAt) / 6e4);
+        console.log(`    ${s.name || s.agent}  (${s.status}, ${uptime}m)`);
+      }
+    }
+    console.log("");
+    return;
+  }
+}
 async function main() {
   const options = parseArgs(process.argv);
   if (options.subcommand === "setup") {
     await runSetupWizard();
     return;
   }
+  if (options.hubInfo || options.hubStop || options.hubStatus) {
+    await handleHubCommand(options);
+    return;
+  }
   if (options.tailscale && options.local) {
     console.error("Error: Cannot use both --tailscale and --local.\n");
     process.exit(1);
@@ -4285,27 +4646,59 @@ async function main() {
     networkingMode = config.networkingMode;
   }
   const [cmd, ...cmdArgs] = options.command;
+  const isFirstSession = await ensureHub();
+  const hubConfig = getHubConfig();
   const token = generateToken();
   const port = await findAvailablePort(options.port);
   const host = options.localhost ? "127.0.0.1" : "0.0.0.0";
   const ip = await resolveSessionIP(networkingMode, options.localhost);
-  const url = `http://${ip}:${port}?token=${token}`;
-  const __dirname = dirname2(fileURLToPath2(import.meta.url));
-  const webClientPath = join4(__dirname, "web-client");
+  const __dirname = dirname3(fileURLToPath3(import.meta.url));
+  const webClientPath = join5(__dirname, "web-client");
   const ptyManager = new PtyManager(cmd, cmdArgs);
   const server = createSyncServer({
     ptyManager,
     token,
     webClientPath,
     host,
-    port
+    port,
+    localTerminalOwnsResize: true
   });
-  if (!options.noQr) {
-    displayQR(url);
-  } else {
+  let registeredSession = null;
+  let heartbeatInterval = null;
+  if (hubConfig) {
+    try {
+      registeredSession = await registerSession({
+        name: cmd,
+        port,
+        token,
+        agent: cmd,
+        cwd: process.cwd(),
+        pid: ptyManager.pid
+      });
+      heartbeatInterval = setInterval(() => {
+        if (registeredSession) {
+          sendHeartbeat(registeredSession.id);
+        }
+      }, 1e4);
+    } catch (err) {
+      console.warn(`  Warning: Failed to register with hub: ${err.message}`);
+    }
+  }
+  const dashboardUrl = hubConfig ? `http://${ip}:${HUB_EXTERNAL_PORT}?token=${hubConfig.masterToken}` : null;
+  if (isFirstSession && dashboardUrl && !options.noQr) {
+    displayQR(dashboardUrl);
+    console.log(`  Dashboard: ${dashboardUrl}`);
+  } else if (isFirstSession && !options.noQr) {
+    const directUrl = `http://${ip}:${port}?token=${token}`;
+    displayQR(directUrl);
+  } else if (dashboardUrl) {
     console.log(`
-  Connect at: ${url}
-`);
+  Session "${cmd}" registered with hub.`);
+    console.log(`  Dashboard: ${dashboardUrl}`);
+    console.log("");
+  } else if (!options.noQr) {
+    const directUrl = `http://${ip}:${port}?token=${token}`;
+    displayQR(directUrl);
   }
   const sleepGuard = preventSleep();
   console.log(`  Server listening on ${host}:${port}`);
@@ -4327,30 +4720,37 @@ async function main() {
   function handleResize() {
     if (process.stdout.columns && process.stdout.rows) {
       ptyManager.resize(process.stdout.columns, process.stdout.rows);
+      server.broadcastResize(process.stdout.columns, process.stdout.rows);
     }
   }
   process.stdout.on("resize", handleResize);
   handleResize();
-  function cleanup() {
+  async function cleanup() {
     if (process.stdin.isTTY) {
       process.stdin.setRawMode(false);
     }
+    if (heartbeatInterval) {
+      clearInterval(heartbeatInterval);
+    }
+    if (registeredSession) {
+      await unregisterSession(registeredSession.id);
+    }
     sleepGuard?.kill();
     server.close();
     ptyManager.kill();
   }
-  ptyManager.onExit((exitCode) => {
+  ptyManager.onExit(async (exitCode) => {
     console.log(`
   Agent exited with code ${exitCode}`);
-    cleanup();
+    await cleanup();
     process.exit(exitCode);
   });
-  process.on("SIGINT", () => {
-    cleanup();
+  process.on("SIGINT", async () => {
+    await cleanup();
     process.exit(0);
   });
-  process.on("SIGTERM", () => {
-    cleanup();
+  process.on("SIGTERM", async () => {
+    await cleanup();
     process.exit(0);
   });
 }