fied 0.1.6 → 0.2.0

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,6 +107,60 @@ 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;
@@ -110,24 +168,20 @@ 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;
+async function share(options) {
+  const relay = options.relay ?? DEFAULT_RELAY;
   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,34 +189,46 @@ 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();
+  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(relay, cryptoKey, keyFragment, pty, options.background);
+  const onUrl = (url) => {
+    if (options.background) {
+      addSession({
+        pid: process.pid,
+        tmuxSession: targetSession,
+        url,
+        relay,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  };
+  await bridge.connect(onUrl);
   const shutdown = () => {
     bridge.destroy();
     pty.kill();
+    if (options.background) removeSession(process.pid);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
   await new Promise((resolve) => {
     pty.onExit(() => {
       bridge.destroy();
+      if (options.background) removeSession(process.pid);
       resolve();
     });
   });
@@ -177,11 +243,12 @@ async function createSession(relay) {
 }
 var WS_CONNECT_TIMEOUT_MS = 1e4;
 var RelayBridge = class {
-  constructor(relay, key, keyFragment, pty) {
+  constructor(relay, key, keyFragment, pty, silent = false) {
     this.relay = relay;
     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,23 +263,26 @@ var RelayBridge = class {
   encoder = new TextEncoder();
   decoder = new TextDecoder();
   sessionId = null;
-  async connect() {
+  async connect(onUrl) {
     if (this.destroyed) return;
     if (!this.sessionId) {
       try {
         this.sessionId = await createSession(this.relay);
       } 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("");
+      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);
@@ -259,7 +329,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();
       }
     });
@@ -300,6 +370,62 @@ var RelayBridge = class {
   }
 };
 
+// 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);
 if (args.includes("--help") || args.includes("-h")) {
@@ -321,18 +447,112 @@ 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];
+    }
+  }
+  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;
+  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].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);
+    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 });
+  }
+}
+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.0",
   "description": "Share your tmux session in the browser with end-to-end encryption",
   "type": "module",
   "bin": {