itwillsync 0.1.0 → 1.0.1

package/README.md

@@ -0,0 +1,127 @@
+# itwillsync
+
+Sync any terminal-based coding agent to your phone over local network. Open source, agent-agnostic, zero cloud.
+
+```
+npx itwillsync -- claude
+npx itwillsync -- aider
+npx itwillsync -- bash
+```
+
+## How it works
+
+1. Run `itwillsync` with your agent command
+2. A QR code appears in your terminal
+3. Scan it on your phone — opens a terminal in your browser
+4. Control your agent from your phone (or both phone and laptop simultaneously)
+
+All data stays on your local network. No cloud, no relay, no account needed.
+
+## Requirements
+
+- Node.js 20+
+- Any terminal-based coding agent (Claude Code, Aider, Goose, Codex, or just `bash`)
+
+## Install & Use
+
+```bash
+# Run directly (no install needed)
+npx itwillsync -- claude
+
+# Or install globally
+npm install -g itwillsync
+itwillsync -- aider --model gpt-4
+```
+
+## Options
+
+```
+--port <number>   Port to listen on (default: 3456)
+--localhost        Bind to 127.0.0.1 only (no LAN access)
+--no-qr           Don't display QR code
+-h, --help        Show help
+-v, --version     Show version
+```
+
+## Remote Access
+
+By default, itwillsync is accessible on your local network (same WiFi). For remote access from anywhere:
+
+- **Tailscale** (recommended): Install on both devices, access via Tailscale IP
+- **WireGuard / VPN**: Any VPN that puts devices on the same network
+- **SSH tunnel**: `ssh -L 3456:localhost:3456 your-machine`
+
+## Security
+
+- Each session generates a random 64-character token
+- Token is embedded in the QR code URL
+- All WebSocket connections require the token
+- No data leaves your network
+
+## Architecture
+
+```
+Your Machine                          Your Phone
+┌─────────────────────┐              ┌──────────────┐
+│ itwillsync          │   WiFi/LAN   │  Browser     │
+│ ├─ PTY (your agent) │◄────────────►│  xterm.js    │
+│ ├─ HTTP server      │  WebSocket   │  terminal    │
+│ └─ WS server        │              └──────────────┘
+└─────────────────────┘
+```
+
+## Session Behavior
+
+- **No timeout**: Sessions live as long as the agent process runs. No TTL, no idle disconnect.
+- **Multiple devices**: Connect from phone, tablet, and laptop simultaneously — all see the same terminal.
+- **Reconnect**: If your phone disconnects (WiFi switch, screen lock), it auto-reconnects and catches up with recent output.
+- **Keepalive**: WebSocket pings every 30s prevent routers from closing idle connections.
+- **One session per instance**: Run multiple `itwillsync` instances on different ports for multiple agents.
+
+## Development
+
+```bash
+# 1. Clone and enter the project
+git clone https://github.com/your-username/itwillsync
+cd itwillsync
+
+# 2. Use Node 22 (required for node-pty native bindings)
+nvm use  # reads .nvmrc
+
+# 3. Install dependencies
+pnpm install
+
+# 4. Build everything (web client first, then CLI)
+pnpm build
+
+# 5. Test it
+node packages/cli/dist/index.js -- bash
+```
+
+### Project Structure
+
+```
+packages/
+├── cli/           # Main npm package — PTY, server, auth, CLI
+└── web-client/    # Browser terminal — xterm.js, mobile-friendly CSS
+```
+
+### Contributing
+
+1. Fork the repo
+2. Create a feature branch
+3. Make your changes
+4. Run `pnpm build` to verify
+5. Open a PR
+
+## Roadmap
+
+- [ ] Chat-style input bar + quick action buttons on mobile
+- [ ] Agent detection + structured view for Claude Code
+- [ ] React Native mobile app
+- [ ] VS Code extension adapter
+- [ ] Agent Sync Protocol specification
+
+## License
+
+MIT

package/dist/index.js

@@ -3776,6 +3776,7 @@ function findAvailablePort(startPort) {
 import { createServer as createServer2 } from "http";
 import { readFile } from "fs/promises";
 import { join, extname } from "path";
+import { gzipSync } from "zlib";
 
 // ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -3794,14 +3795,34 @@ var MIME_TYPES = {
   ".png": "image/png",
   ".ico": "image/x-icon"
 };
-async function serveStaticFile(webClientPath, filePath, res) {
+var COMPRESSIBLE = /* @__PURE__ */ new Set([".html", ".js", ".css", ".json", ".svg"]);
+var gzipCache = /* @__PURE__ */ new Map();
+async function serveStaticFile(webClientPath, filePath, req, res) {
   const fullPath = join(webClientPath, filePath);
   const ext = extname(fullPath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
   try {
-    const content = await readFile(fullPath);
-    res.writeHead(200, { "Content-Type": contentType });
-    res.end(content);
+    const raw = await readFile(fullPath);
+    const acceptsGzip = (req.headers["accept-encoding"] || "").includes("gzip");
+    if (acceptsGzip && COMPRESSIBLE.has(ext)) {
+      let compressed = gzipCache.get(fullPath);
+      if (!compressed) {
+        compressed = gzipSync(raw);
+        gzipCache.set(fullPath, compressed);
+      }
+      res.writeHead(200, {
+        "Content-Type": contentType,
+        "Content-Encoding": "gzip",
+        "Content-Length": compressed.length
+      });
+      res.end(compressed);
+    } else {
+      res.writeHead(200, {
+        "Content-Type": contentType,
+        "Content-Length": raw.length
+      });
+      res.end(raw);
+    }
   } catch {
     res.writeHead(404, { "Content-Type": "text/plain" });
     res.end("Not Found");
@@ -3820,7 +3841,7 @@ function createSyncServer(options) {
     if (pathname === "/") {
       pathname = "/index.html";
     }
-    await serveStaticFile(webClientPath, pathname, res);
+    await serveStaticFile(webClientPath, pathname, req, res);
   });
   const wssServer = new import_websocket_server.default({ noServer: true });
   httpServer.on("upgrade", (req, socket, head) => {
@@ -3921,6 +3942,29 @@ function displayQR(url) {
 // src/index.ts
 import { fileURLToPath } from "url";
 import { join as join2, dirname } from "path";
+import { spawn as spawn2 } from "child_process";
+function preventSleep() {
+  try {
+    if (process.platform === "darwin") {
+      const child = spawn2("caffeinate", ["-i", "-w", String(process.pid)], {
+        stdio: "ignore",
+        detached: true
+      });
+      child.unref();
+      return child;
+    } else if (process.platform === "linux") {
+      return spawn2("systemd-inhibit", [
+        "--what=idle",
+        "--who=itwillsync",
+        "--why=Terminal sync session active",
+        "sleep",
+        "infinity"
+      ], { stdio: "ignore" });
+    }
+  } catch {
+  }
+  return null;
+}
 var DEFAULT_PORT = 3456;
 function parseArgs(argv) {
   const options = {
@@ -4010,9 +4054,11 @@ async function main() {
   Connect at: ${url}
 `);
   }
+  const sleepGuard = preventSleep();
   console.log(`  Server listening on ${host}:${port}`);
   console.log(`  Running: ${options.command.join(" ")}`);
   console.log(`  PID: ${ptyManager.pid}`);
+  console.log(`  Sleep prevention: ${sleepGuard ? "active" : "unavailable"}`);
   console.log("");
   if (process.stdin.isTTY) {
     process.stdin.setRawMode(true);
@@ -4036,6 +4082,7 @@ async function main() {
     if (process.stdin.isTTY) {
       process.stdin.setRawMode(false);
     }
+    sleepGuard?.kill();
     server.close();
     ptyManager.kill();
   }