fied 0.1.3 → 0.1.5

package/dist/bin.js

@@ -108,6 +108,8 @@ var DEFAULT_RELAY = "https://fied.app";
 var MSG_TERMINAL_OUTPUT = 1;
 var MSG_TERMINAL_INPUT = 2;
 var MSG_RESIZE = 3;
+var RECONNECT_BASE_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
 async function share(options2) {
   const relay = options2.relay ?? DEFAULT_RELAY;
   const sessions = listSessions();
@@ -143,22 +145,27 @@ async function share(options2) {
   const rawKey = await generateKey();
   const cryptoKey = await importKey(rawKey);
   const keyFragment = toBase64Url(rawKey);
-  const sessionId = await createSession(relay);
-  const url = `${relay}/s/${sessionId}#${keyFragment}`;
+  const pty = attachSession(targetSession, cols, rows);
   console.log("");
   console.log("  \x1B[1m\x1B[32mfied\x1B[0m \u2014 encrypted terminal sharing");
   console.log("");
   console.log(`  Session:  ${targetSession}`);
   console.log(`  Size:     ${cols}x${rows}`);
   console.log("");
-  console.log(`  \x1B[1mShare this link:\x1B[0m`);
-  console.log(`  \x1B[4m\x1B[36m${url}\x1B[0m`);
-  console.log("");
-  console.log("  \x1B[2mThe encryption key is in the URL fragment (#) \u2014 the server never sees it.\x1B[0m");
-  console.log("  \x1B[2mPress Ctrl+C to stop sharing.\x1B[0m");
-  console.log("");
-  const pty = attachSession(targetSession, cols, rows);
-  await connectToRelay(relay, sessionId, cryptoKey, pty);
+  const bridge = new RelayBridge(relay, cryptoKey, keyFragment, pty);
+  await bridge.connect();
+  const shutdown = () => {
+    bridge.destroy();
+    pty.kill();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise((resolve) => {
+    pty.onExit(() => {
+      bridge.destroy();
+      resolve();
+    });
+  });
 }
 async function createSession(relay) {
   const res = await fetch(`${relay}/api/sessions`, { method: "POST" });
@@ -168,39 +175,71 @@ async function createSession(relay) {
   const data = await res.json();
   return data.sessionId;
 }
-async function connectToRelay(relay, sessionId, key, pty) {
-  return new Promise((resolve, reject) => {
-    const wsUrl = relay.replace(/^http/, "ws") + `/api/sessions/${sessionId}/ws?role=host`;
+var WS_CONNECT_TIMEOUT_MS = 1e4;
+var RelayBridge = class {
+  constructor(relay, key, keyFragment, pty) {
+    this.relay = relay;
+    this.key = key;
+    this.keyFragment = keyFragment;
+    this.pty = pty;
+    this.pty.onData((data) => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.sendEncrypted(MSG_TERMINAL_OUTPUT, this.encoder.encode(data));
+      }
+    });
+  }
+  ws = null;
+  destroyed = false;
+  backoff = RECONNECT_BASE_MS;
+  reconnectTimer = null;
+  connectTimeout = null;
+  encoder = new TextEncoder();
+  decoder = new TextDecoder();
+  firstConnect = true;
+  async connect() {
+    if (this.destroyed) return;
+    let sessionId;
+    try {
+      sessionId = await createSession(this.relay);
+    } catch {
+      if (this.firstConnect) {
+        console.error("  \x1B[31mRelay unreachable, retrying...\x1B[0m");
+      }
+      this.scheduleReconnect();
+      return;
+    }
+    const url = `${this.relay}/s/${sessionId}#${this.keyFragment}`;
+    if (this.firstConnect) {
+      console.log(`  \x1B[1mShare this link:\x1B[0m`);
+      console.log(`  \x1B[4m\x1B[36m${url}\x1B[0m`);
+      console.log("");
+      console.log("  \x1B[2mThe encryption key is in the URL fragment (#) \u2014 the server never sees it.\x1B[0m");
+      console.log("  \x1B[2mPress Ctrl+C to stop sharing.\x1B[0m");
+      console.log("");
+    } else {
+      console.error(`  \x1B[32mReconnected.\x1B[0m New link: \x1B[4m\x1B[36m${url}\x1B[0m`);
+    }
+    this.firstConnect = false;
+    const wsUrl = this.relay.replace(/^http/, "ws") + `/api/sessions/${sessionId}/ws?role=host`;
     const ws = new WebSocket(wsUrl);
     ws.binaryType = "arraybuffer";
-    let alive = true;
-    let heartbeatTimer;
+    this.ws = ws;
+    this.connectTimeout = setTimeout(() => {
+      if (ws.readyState !== WebSocket.OPEN) {
+        ws.terminate();
+      }
+    }, WS_CONNECT_TIMEOUT_MS);
     ws.on("open", () => {
-      heartbeatTimer = setInterval(() => {
-        if (ws.readyState === WebSocket.OPEN) {
-          ws.ping();
-        }
-      }, 3e4);
-      const resizePayload = JSON.stringify({
-        cols: pty.cols,
-        rows: pty.rows
-      });
-      sendEncrypted(ws, key, MSG_RESIZE, new TextEncoder().encode(resizePayload));
-    });
-    pty.onData((data) => {
-      if (ws.readyState === WebSocket.OPEN) {
-        sendEncrypted(ws, key, MSG_TERMINAL_OUTPUT, new TextEncoder().encode(data));
+      if (this.connectTimeout) {
+        clearTimeout(this.connectTimeout);
+        this.connectTimeout = null;
       }
+      this.backoff = RECONNECT_BASE_MS;
     });
-    pty.onExit(({ exitCode }) => {
-      alive = false;
-      if (heartbeatTimer) clearInterval(heartbeatTimer);
-      ws.close();
-      resolve();
-    });
-    ws.on("message", async (raw) => {
-      if (typeof raw === "string") {
-        if (raw === "__fied_ping__") {
+    ws.on("message", async (raw, isBinary) => {
+      if (!isBinary) {
+        const text = this.decoder.decode(raw);
+        if (text === "__fied_ping__") {
           ws.send("__fied_pong__");
         }
         return;
@@ -209,50 +248,63 @@ async function connectToRelay(relay, sessionId, key, pty) {
         const data = new Uint8Array(raw);
         const frame = parseFrame(data);
         if (frame.type === MSG_TERMINAL_INPUT) {
-          const plaintext = await decrypt(key, frame.iv, frame.ciphertext);
-          pty.write(new TextDecoder().decode(plaintext));
+          const plaintext = await decrypt(this.key, frame.iv, frame.ciphertext);
+          this.pty.write(this.decoder.decode(plaintext));
         } else if (frame.type === MSG_RESIZE) {
-          const plaintext = await decrypt(key, frame.iv, frame.ciphertext);
-          const { cols, rows } = JSON.parse(new TextDecoder().decode(plaintext));
-          pty.resize(cols, rows);
+          const plaintext = await decrypt(this.key, frame.iv, frame.ciphertext);
+          const { cols, rows } = JSON.parse(this.decoder.decode(plaintext));
+          this.pty.resize(cols, rows);
         }
-      } catch (err) {
-        console.error("Failed to process incoming message:", err);
+      } catch {
       }
     });
     ws.on("close", () => {
-      if (heartbeatTimer) clearInterval(heartbeatTimer);
-      if (alive) {
-        pty.kill();
+      if (this.connectTimeout) {
+        clearTimeout(this.connectTimeout);
+        this.connectTimeout = null;
+      }
+      this.ws = null;
+      if (!this.destroyed) {
+        console.error("  \x1B[33mConnection lost, reconnecting...\x1B[0m");
+        this.scheduleReconnect();
       }
-      resolve();
-    });
-    ws.on("error", (err) => {
-      console.error("WebSocket error:", err.message);
-    });
-    process.on("SIGINT", () => {
-      alive = false;
-      if (heartbeatTimer) clearInterval(heartbeatTimer);
-      ws.close();
-      pty.kill();
     });
-    process.on("SIGTERM", () => {
-      alive = false;
-      if (heartbeatTimer) clearInterval(heartbeatTimer);
-      ws.close();
-      pty.kill();
+    ws.on("error", () => {
     });
-  });
-}
-async function sendEncrypted(ws, key, type, plaintext) {
-  try {
-    const { iv, ciphertext } = await encrypt(key, plaintext);
-    const frame = frameMessage(type, iv, ciphertext);
-    ws.send(frame);
-  } catch (err) {
-    console.error("Encryption failed:", err);
   }
-}
+  destroy() {
+    this.destroyed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.connectTimeout) {
+      clearTimeout(this.connectTimeout);
+      this.connectTimeout = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.destroyed || this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, this.backoff);
+    this.backoff = Math.min(this.backoff * 2, RECONNECT_MAX_MS);
+  }
+  async sendEncrypted(type, plaintext) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    try {
+      const { iv, ciphertext } = await encrypt(this.key, plaintext);
+      const frame = frameMessage(type, iv, ciphertext);
+      this.ws.send(frame);
+    } catch {
+    }
+  }
+};
 
 // src/bin.ts
 var args = process.argv.slice(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fied",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Share your tmux session in the browser with end-to-end encryption",
   "type": "module",
   "bin": {