fied 0.1.6 → 0.2.1

package/dist/bin.js

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 
+// src/bin.ts
+import { spawn as spawnChild } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
 // src/index.ts
 import WebSocket from "ws";
 
@@ -103,31 +107,89 @@ function attachSession(sessionName, cols, rows) {
   });
 }
 
+// src/store.ts
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+var STORE_DIR = join(homedir(), ".fied");
+var STORE_FILE = join(STORE_DIR, "sessions.json");
+function ensureDir() {
+  mkdirSync(STORE_DIR, { recursive: true });
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function loadSessions() {
+  try {
+    const raw = readFileSync(STORE_FILE, "utf-8");
+    const entries = JSON.parse(raw);
+    const alive = entries.filter((e) => isAlive(e.pid));
+    if (alive.length !== entries.length) {
+      saveSessions(alive);
+    }
+    return alive;
+  } catch {
+    return [];
+  }
+}
+function saveSessions(entries) {
+  ensureDir();
+  writeFileSync(STORE_FILE, JSON.stringify(entries, null, 2));
+}
+function addSession(entry) {
+  const entries = loadSessions();
+  entries.push(entry);
+  saveSessions(entries);
+}
+function removeSession(pid) {
+  const entries = loadSessions();
+  saveSessions(entries.filter((e) => e.pid !== pid));
+}
+function stopSession(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+    removeSession(pid);
+    return true;
+  } catch {
+    removeSession(pid);
+    return false;
+  }
+}
+
 // src/index.ts
 var DEFAULT_RELAY = "https://fied.app";
 var MSG_TERMINAL_OUTPUT = 1;
 var MSG_TERMINAL_INPUT = 2;
 var MSG_RESIZE = 3;
+var RESIZE_MIN_COLS = 20;
+var RESIZE_MAX_COLS = 1e3;
+var RESIZE_MIN_ROWS = 5;
+var RESIZE_MAX_ROWS = 300;
+var MAX_INVALID_RESIZE_FRAMES = 5;
 var RECONNECT_BASE_MS = 1e3;
 var RECONNECT_MAX_MS = 3e4;
-async function share(options2) {
-  const relay = options2.relay ?? DEFAULT_RELAY;
+async function share(options) {
+  const relayTarget = parseRelayTarget(
+    options.relay ?? DEFAULT_RELAY,
+    options.allowInsecureRelay ?? process.env.FIED_ALLOW_INSECURE_RELAY === "1"
+  );
   const sessions = listSessions();
   if (sessions.length === 0) {
     console.error("No tmux sessions found. Start one with: tmux new -s mysession");
     process.exit(1);
   }
   let targetSession;
-  if (options2.session) {
+  if (options.session) {
     const found = sessions.find(
-      (s) => s.name === options2.session || s.id === options2.session
+      (s) => s.name === options.session || s.id === options.session
     );
     if (!found) {
-      console.error(`tmux session "${options2.session}" not found.`);
-      console.error("Available sessions:");
-      for (const s of sessions) {
-        console.error(`  ${s.name} (${s.windows} windows${s.attached ? ", attached" : ""})`);
-      }
+      console.error(`tmux session "${options.session}" not found.`);
       process.exit(1);
     }
     targetSession = found.name;
@@ -135,40 +197,91 @@ async function share(options2) {
     targetSession = sessions[0].name;
   } else {
     console.error("Multiple tmux sessions found. Specify one with --session:");
-    for (const s of sessions) {
-      console.error(`  ${s.name} (${s.windows} windows${s.attached ? ", attached" : ""})`);
-    }
     process.exit(1);
   }
-  const cols = options2.cols ?? process.stdout.columns ?? 80;
-  const rows = options2.rows ?? process.stdout.rows ?? 24;
+  const cols = options.cols ?? process.stdout.columns ?? 80;
+  const rows = options.rows ?? process.stdout.rows ?? 24;
   const rawKey = await generateKey();
   const cryptoKey = await importKey(rawKey);
   const keyFragment = toBase64Url(rawKey);
   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("");
-  const bridge = new RelayBridge(relay, cryptoKey, keyFragment, pty);
-  await bridge.connect();
-  const shutdown = () => {
+  if (!options.background) {
+    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("");
+  }
+  const bridge = new RelayBridge(relayTarget, cryptoKey, keyFragment, pty, options.background);
+  const onUrl = (url) => {
+    if (options.background) {
+      addSession({
+        pid: process.pid,
+        tmuxSession: targetSession,
+        url,
+        relay: relayTarget.httpBase.toString(),
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  };
+  await bridge.connect(onUrl);
+  let closed = false;
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
     bridge.destroy();
-    pty.kill();
+    try {
+      pty.kill();
+    } catch {
+    }
+    if (options.background) {
+      removeSession(process.pid);
+    }
+  };
+  const exitNow = (code) => {
+    cleanup();
+    process.exit(code);
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process.once("SIGINT", () => exitNow(0));
+  process.once("SIGTERM", () => exitNow(0));
   await new Promise((resolve) => {
     pty.onExit(() => {
-      bridge.destroy();
+      cleanup();
       resolve();
     });
   });
 }
-async function createSession(relay) {
-  const res = await fetch(`${relay}/api/sessions`, { method: "POST" });
+function parseRelayTarget(relay, allowInsecureRelay) {
+  let parsed;
+  try {
+    parsed = new URL(relay);
+  } catch {
+    throw new Error(`Invalid relay URL: ${relay}`);
+  }
+  const isHttps = parsed.protocol === "https:";
+  const isHttp = parsed.protocol === "http:";
+  const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "::1";
+  if (!isHttps) {
+    if (!(isHttp && isLocalhost && allowInsecureRelay)) {
+      throw new Error(
+        "Relay must use https://. For local development, use http://localhost with --allow-insecure-relay or FIED_ALLOW_INSECURE_RELAY=1"
+      );
+    }
+  }
+  const httpBase = new URL(parsed.toString());
+  httpBase.hash = "";
+  httpBase.search = "";
+  if (!httpBase.pathname.endsWith("/")) {
+    httpBase.pathname = `${httpBase.pathname}/`;
+  }
+  const wsBase = new URL(httpBase.toString());
+  wsBase.protocol = httpBase.protocol === "https:" ? "wss:" : "ws:";
+  return { httpBase, wsBase };
+}
+async function createSession(relayHttpBase) {
+  const url = new URL("api/sessions", relayHttpBase);
+  const res = await fetch(url.toString(), { method: "POST" });
   if (!res.ok) {
     throw new Error(`Failed to create session: ${res.status} ${res.statusText}`);
   }
@@ -177,11 +290,12 @@ async function createSession(relay) {
 }
 var WS_CONNECT_TIMEOUT_MS = 1e4;
 var RelayBridge = class {
-  constructor(relay, key, keyFragment, pty) {
-    this.relay = relay;
+  constructor(relayTarget, key, keyFragment, pty, silent = false) {
+    this.relayTarget = relayTarget;
     this.key = key;
     this.keyFragment = keyFragment;
     this.pty = pty;
+    this.silent = silent;
     this.pty.onData((data) => {
       if (this.ws?.readyState === WebSocket.OPEN) {
         this.sendEncrypted(MSG_TERMINAL_OUTPUT, this.encoder.encode(data));
@@ -196,26 +310,36 @@ var RelayBridge = class {
   encoder = new TextEncoder();
   decoder = new TextDecoder();
   sessionId = null;
-  async connect() {
+  onUrl = null;
+  invalidResizeFrames = 0;
+  async connect(onUrl) {
     if (this.destroyed) return;
+    if (onUrl) {
+      this.onUrl = onUrl;
+    }
     if (!this.sessionId) {
       try {
-        this.sessionId = await createSession(this.relay);
+        this.sessionId = await createSession(this.relayTarget.httpBase);
       } catch {
-        console.error("  \x1B[31mRelay unreachable, retrying...\x1B[0m");
+        if (!this.silent) console.error("  \x1B[31mRelay unreachable, retrying...\x1B[0m");
         this.scheduleReconnect();
         return;
       }
-      const url = `${this.relay}/s/${this.sessionId}#${this.keyFragment}`;
-      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 shareUrl = new URL(`s/${this.sessionId}`, this.relayTarget.httpBase);
+      const url = `${shareUrl.toString()}#${this.keyFragment}`;
+      this.onUrl?.(url);
+      if (!this.silent) {
+        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 wsUrl = this.relay.replace(/^http/, "ws") + `/api/sessions/${this.sessionId}/ws?role=host`;
-    const ws = new WebSocket(wsUrl);
+    const wsUrl = new URL(`api/sessions/${this.sessionId}/ws`, this.relayTarget.wsBase);
+    wsUrl.searchParams.set("role", "host");
+    const ws = new WebSocket(wsUrl.toString());
     ws.binaryType = "arraybuffer";
     this.ws = ws;
     this.connectTimeout = setTimeout(() => {
@@ -246,10 +370,22 @@ var RelayBridge = class {
           this.pty.write(this.decoder.decode(plaintext));
         } else if (frame.type === MSG_RESIZE) {
           const plaintext = await decrypt(this.key, frame.iv, frame.ciphertext);
-          const { cols, rows } = JSON.parse(this.decoder.decode(plaintext));
-          this.pty.resize(cols, rows);
+          const resize = parseResizePayload(this.decoder.decode(plaintext));
+          if (!resize) {
+            this.invalidResizeFrames += 1;
+            if (this.invalidResizeFrames >= MAX_INVALID_RESIZE_FRAMES) {
+              ws.close(1008, "invalid resize frames");
+            }
+            return;
+          }
+          this.invalidResizeFrames = 0;
+          this.pty.resize(resize.cols, resize.rows);
+        }
+      } catch (err) {
+        if (!this.silent) {
+          const detail = err instanceof Error ? err.message : String(err);
+          console.error(`  \x1B[33mIncoming frame rejected:\x1B[0m ${detail}`);
         }
-      } catch {
       }
     });
     ws.on("close", () => {
@@ -259,7 +395,7 @@ var RelayBridge = class {
       }
       this.ws = null;
       if (!this.destroyed) {
-        console.error("  \x1B[33mConnection lost, reconnecting...\x1B[0m");
+        if (!this.silent) console.error("  \x1B[33mConnection lost, reconnecting...\x1B[0m");
         this.scheduleReconnect();
       }
     });
@@ -295,10 +431,86 @@ var RelayBridge = class {
       const { iv, ciphertext } = await encrypt(this.key, plaintext);
       const frame = frameMessage(type, iv, ciphertext);
       this.ws.send(frame);
-    } catch {
+    } catch (err) {
+      if (!this.silent) {
+        const detail = err instanceof Error ? err.message : String(err);
+        console.error(`  \x1B[33mEncryption failed:\x1B[0m ${detail}`);
+      }
     }
   }
 };
+function parseResizePayload(payload) {
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const typed = parsed;
+  if (!Number.isInteger(typed.cols) || !Number.isInteger(typed.rows)) return null;
+  const cols = typed.cols;
+  const rows = typed.rows;
+  if (cols < RESIZE_MIN_COLS || cols > RESIZE_MAX_COLS) return null;
+  if (rows < RESIZE_MIN_ROWS || rows > RESIZE_MAX_ROWS) return null;
+  return { cols, rows };
+}
+
+// src/prompt.ts
+import { createInterface } from "node:readline";
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function pickSession(names) {
+  console.error("");
+  console.error("  \x1B[1mSelect a tmux session:\x1B[0m");
+  console.error("");
+  for (let i = 0; i < names.length; i++) {
+    console.error(`    \x1B[36m${i + 1}\x1B[0m) ${names[i]}`);
+  }
+  console.error("");
+  while (true) {
+    const answer = await ask("  Choice: ");
+    const idx = parseInt(answer, 10) - 1;
+    if (idx >= 0 && idx < names.length) {
+      return names[idx];
+    }
+    console.error(`  \x1B[33mEnter a number between 1 and ${names.length}\x1B[0m`);
+  }
+}
+async function confirm(question, defaultYes = false) {
+  const hint = defaultYes ? "Y/n" : "y/N";
+  const answer = await ask(`  ${question} [${hint}]: `);
+  if (answer === "") return defaultYes;
+  return answer.toLowerCase().startsWith("y");
+}
+async function pickManageAction(count) {
+  console.error("");
+  console.error(`    \x1B[36mn\x1B[0m) Start new session`);
+  console.error(`    \x1B[36ms\x1B[0m) Stop a session`);
+  console.error(`    \x1B[36mq\x1B[0m) Quit`);
+  console.error("");
+  while (true) {
+    const answer = await ask("  Action: ");
+    const a = answer.toLowerCase();
+    if (a === "n" || a === "s" || a === "q") return a;
+    const idx = parseInt(answer, 10);
+    if (idx >= 1 && idx <= count) return `stop:${idx}`;
+    console.error("  \x1B[33mEnter n, s, or q\x1B[0m");
+  }
+}
+async function pickStop(count) {
+  const answer = await ask("  Stop which session #: ");
+  const idx = parseInt(answer, 10) - 1;
+  if (idx >= 0 && idx < count) return idx;
+  return null;
+}
 
 // src/bin.ts
 var args = process.argv.slice(2);
@@ -312,6 +524,7 @@ if (args.includes("--help") || args.includes("-h")) {
   \x1B[1mOptions:\x1B[0m
     --session, -s <name>   tmux session to share (auto-detected if only one)
     --relay <url>          relay server URL (default: https://fied.app)
+    --allow-insecure-relay allow http://localhost relay (dev only)
     --help, -h             show this help
 
   \x1B[1mExamples:\x1B[0m
@@ -321,18 +534,118 @@ if (args.includes("--help") || args.includes("-h")) {
 `);
   process.exit(0);
 }
-var options = {};
-for (let i = 0; i < args.length; i++) {
-  if ((args[i] === "--session" || args[i] === "-s") && args[i + 1]) {
-    options.session = args[++i];
-  } else if (args[i] === "--relay" && args[i + 1]) {
-    options.relay = args[++i];
-  } else {
-    console.error(`Unknown option: ${args[i]}`);
+if (args.includes("--__daemon")) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === "--session" || args[i] === "-s") && args[i + 1]) {
+      options.session = args[++i];
+    } else if (args[i] === "--relay" && args[i + 1]) {
+      options.relay = args[++i];
+    } else if (args[i] === "--allow-insecure-relay") {
+      options.allowInsecureRelay = true;
+    }
+  }
+  share({ ...options, background: true }).catch(() => process.exit(1));
+} else {
+  main().catch((err) => {
+    console.error("Fatal:", err.message ?? err);
+    process.exit(1);
+  });
+}
+async function main() {
+  let relay;
+  let session;
+  let allowInsecureRelay = false;
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === "--session" || args[i] === "-s") && args[i + 1]) {
+      session = args[++i];
+    } else if (args[i] === "--relay" && args[i + 1]) {
+      relay = args[++i];
+    } else if (args[i] === "--allow-insecure-relay") {
+      allowInsecureRelay = true;
+    } else if (!args[i].startsWith("-")) {
+      continue;
+    } else {
+      console.error(`Unknown option: ${args[i]}`);
+      process.exit(1);
+    }
+  }
+  const active = loadSessions();
+  if (active.length > 0 && !session) {
+    console.error("");
+    console.error("  \x1B[1m\x1B[32mfied\x1B[0m \u2014 active sessions");
+    console.error("");
+    for (let i = 0; i < active.length; i++) {
+      const s = active[i];
+      const age = timeSince(new Date(s.startedAt));
+      console.error(`    \x1B[36m${i + 1}\x1B[0m) \x1B[1m${s.tmuxSession}\x1B[0m  ${age} ago`);
+      console.error(`       \x1B[4m\x1B[36m${s.url}\x1B[0m`);
+    }
+    const action = await pickManageAction(active.length);
+    if (action === "q") {
+      process.exit(0);
+    }
+    if (action === "s") {
+      const idx = await pickStop(active.length);
+      if (idx !== null) {
+        const entry = active[idx];
+        stopSession(entry.pid);
+        console.error(`  \x1B[32mStopped\x1B[0m ${entry.tmuxSession}`);
+      }
+      process.exit(0);
+    }
+    if (action.startsWith("stop:")) {
+      const idx = parseInt(action.split(":")[1], 10) - 1;
+      const entry = active[idx];
+      stopSession(entry.pid);
+      console.error(`  \x1B[32mStopped\x1B[0m ${entry.tmuxSession}`);
+      process.exit(0);
+    }
+  }
+  const tmuxSessions = listSessions();
+  if (tmuxSessions.length === 0) {
+    console.error("No tmux sessions found. Start one with: tmux new -s mysession");
     process.exit(1);
   }
+  if (!session) {
+    if (tmuxSessions.length === 1) {
+      session = tmuxSessions[0].name;
+    } else {
+      session = await pickSession(tmuxSessions.map((s) => {
+        const tag = s.attached ? " \x1B[2m(attached)\x1B[0m" : "";
+        return `${s.name} \u2014 ${s.windows} window${s.windows !== 1 ? "s" : ""}${tag}`;
+      }));
+      session = session.split(" \u2014 ")[0].trim();
+    }
+  }
+  const background = await confirm("Run in background?");
+  if (background) {
+    const binPath = fileURLToPath(import.meta.url);
+    const childArgs = ["--__daemon", "--session", session];
+    if (relay) childArgs.push("--relay", relay);
+    if (allowInsecureRelay) childArgs.push("--allow-insecure-relay");
+    const child = spawnChild(process.execPath, [binPath, ...childArgs], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    console.error("");
+    console.error(`  \x1B[1m\x1B[32mfied\x1B[0m \u2014 started in background (PID ${child.pid})`);
+    console.error(`  Session: ${session}`);
+    console.error("  Run \x1B[1mnpx fied\x1B[0m again to manage.");
+    console.error("");
+    setTimeout(() => process.exit(0), 500);
+  } else {
+    await share({ session, relay, allowInsecureRelay });
+  }
+}
+function timeSince(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+  const days = Math.floor(hours / 24);
+  return `${days}d`;
 }
-share(options).catch((err) => {
-  console.error("Fatal:", err.message ?? err);
-  process.exit(1);
-});

package/package.json

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