webtun 1.5.2 → 1.5.3

package/README.md

@@ -68,7 +68,7 @@ git clone https://github.com/unn-Known1/webtun.git && cd webtun && ./setup.sh &&
 - **Multi-tab** — drag to reorder, side-by-side sessions
 - **Bracketed paste** — Ctrl+V works in TUI apps (vim, nano, htop)
 - **Command history** — keystroke-based capture, strips ANSI/control sequences
-- **tmux sessions** — persistent sessions survive page reload
+- **Session persistence** — tmux or in-memory PTY; tabs survive page reload (all platforms)
 - **Keyboard Shortcuts** — reference dialog in the overflow menu (Ctrl+P/T/W/B/F, etc.)
 
 ### File Explorer
@@ -175,6 +175,10 @@ git clone https://github.com/unn-Known1/webtun.git && cd webtun && ./setup.sh &&
 
 ## Changelog
 
+### v1.5.3
+- Terminal session persistence without tmux (in-memory PTY on Windows + Linux)
+- Session IDs always generated; tabs now survive page reload on all platforms
+
 ### v1.5.2
 - UI/UX audit fixes: theme-aware xterm selection color, `--fg3` across all 6 themes
 - Replaced native `confirm()` with a theme-aware, focus-trapped dialog

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webtun",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "Self-hosted web terminal with Cloudflare Tunnel, file explorer, and PWA support",
   "author": {
     "name": "Gaurang Patel",

package/public/index.html

@@ -2068,7 +2068,7 @@ function hideTermLoading(tab) {
 
 function newTab(title, sessionId, dir) {
   const id = ++tabCounter;
-  const sid = sessionId || (hasTmux ? uuid() : null);
+  const sid = sessionId || uuid();
   const tab = { id, sessionId: sid, title: title || `Term ${nextTermNumber()}`, term: null, fitAddon: null, searchAddon: null, ws: null, el: null, wrapper: null, closed: false, reconnectDelay: 1000, dataDisposable: null, resizeDisposable: null, resizeObserver: null, cwd: dir || currentPath };
   tabs.push(tab);
   createTabButton(tab);
@@ -2348,7 +2348,7 @@ async function closeTab(e, id) {
   tab.term?.dispose();
   tab.el?.remove();
   tab.wrapper?.remove();
-  // Kill the backing tmux session so it doesn't pile up
+  // Kill the backing session (tmux or in-memory) so it doesn't pile up
   if (tab.sessionId) api(`/api/sessions/${tab.sessionId}`, { method: 'DELETE' });
   tabs = tabs.filter(t => t.id !== id);
   saveTabState();
@@ -5387,6 +5387,9 @@ function setupDragDrop() {
                 const traversed = await traverseDirectoryEntry(entry);
                 filesToUpload.push(...traversed);
               } catch(e) { console.warn(e); }
+            } else {
+              const file = item.getAsFile();
+              if (file) filesToUpload.push({ file, path: file.name });
             }
           }
         }

package/server.js

@@ -1272,9 +1272,12 @@ app.delete('/api/history/:index', checkPin, (req, res) => {
   res.json({ success: true, history: cmdHistory });
 });
 
-// ── Session persistence via tmux ──────────────────────────────────────
+// ── Session persistence ──────────────────────────────────────────────
 const TMUX = (() => { try { return execSync('command -v tmux', { stdio: ['ignore','pipe','ignore'] }).toString().trim(); } catch { return null; } })();
 
+// In-memory PTY session store — enables persistence without tmux (Windows + Linux)
+const ptySessions = new Map(); // sessionId -> { proc, drainCheck, createdAt }
+
 function isValidPID(pid) {
   return typeof pid === 'number' && Number.isInteger(pid) && pid > 0;
 }
@@ -1301,22 +1304,38 @@ function tmuxSessionExists(name) {
 }
 
 app.get('/api/sessions', checkPin, (req, res) => {
-  if (!TMUX) return res.json({ tmux: false, sessions: [] });
-  try {
-    const out = execFileSync(TMUX, ['list-sessions', '-F', '#{session_name}'], { encoding: 'utf8' }).trim();
-    const sessions = out.split('\n')
-      .filter(s => s.startsWith('wt-'))
-      .map(s => ({ id: s.replace(/^wt-/, ''), name: s }));
-    res.json({ tmux: true, sessions });
-  } catch {
-    res.json({ tmux: true, sessions: [] });
+  if (TMUX) {
+    try {
+      const out = execFileSync(TMUX, ['list-sessions', '-F', '#{session_name}'], { encoding: 'utf8' }).trim();
+      const sessions = out.split('\n')
+        .filter(s => s.startsWith('wt-'))
+        .map(s => ({ id: s.replace(/^wt-/, ''), name: s }));
+      return res.json({ tmux: true, sessions });
+    } catch {
+      return res.json({ tmux: true, sessions: [] });
+    }
+  }
+  // In-memory sessions (no tmux)
+  const sessions = [];
+  for (const [id] of ptySessions) {
+    sessions.push({ id, name: 'wt-' + id });
   }
+  res.json({ tmux: false, sessions });
 });
 
 app.delete('/api/sessions/:id', checkPin, (req, res) => {
-  if (!TMUX) return res.json({ success: false });
-  const name = 'wt-' + req.params.id.replace(/[^a-zA-Z0-9_-]/g, '');
-  try { execFileSync(TMUX, ['kill-session', '-t', name], { stdio: 'ignore' }); } catch {}
+  const id = req.params.id.replace(/[^a-zA-Z0-9_-]/g, '');
+  if (TMUX) {
+    const name = 'wt-' + id;
+    try { execFileSync(TMUX, ['kill-session', '-t', name], { stdio: 'ignore' }); } catch {}
+    return res.json({ success: true });
+  }
+  // In-memory session
+  const entry = ptySessions.get(id);
+  if (entry) {
+    try { entry.proc.kill(); } catch {}
+    ptySessions.delete(id);
+  }
   res.json({ success: true });
 });
 
@@ -1378,8 +1397,28 @@ wss.on('connection', (ws, req) => {
   };
 
   let proc;
+  let reattached = false;
   try {
-    if (TMUX && sessionId) {
+    if (sessionId && !TMUX) {
+      // ── In-memory PTY persistence (no tmux needed) ──
+      const existing = ptySessions.get(sessionId);
+      if (existing && existing.proc && !existing.exited) {
+        // Reattach: remove old listeners, reuse the running PTY
+        proc = existing.proc;
+        proc.removeAllListeners('data');
+        proc.removeAllListeners('exit');
+        proc.resize(cols, rows);
+        reattached = true;
+      } else {
+        // New in-memory session
+        if (existing) ptySessions.delete(sessionId);
+        const shellArgs = os.platform() === 'win32' ? ['-NoLogo'] : ['-l'];
+        proc = pty.spawn(SHELL, shellArgs, {
+          name: 'xterm-256color', cols, rows, cwd,
+          env: sessionEnv
+        });
+      }
+    } else if (TMUX && sessionId) {
       const tmuxName = 'wt-' + sessionId;
       const exists   = tmuxSessionExists(tmuxName);
 
@@ -1413,6 +1452,12 @@ wss.on('connection', (ws, req) => {
   const HIGH_WATER = 4 * 1024 * 1024; // 4MB — pause PTY above this
   const LOW_WATER  = 1 * 1024 * 1024; // 1MB — resume PTY below this
 
+  const drainCheck = setInterval(() => {
+    if (paused && ws.bufferedAmount < LOW_WATER) {
+      try { proc.resume(); paused = false; } catch (_) {}
+    }
+  }, 50);
+
   proc.onData(data => {
     if (ws.readyState !== WebSocket.OPEN) return;
     send(0x00, data);
@@ -1422,19 +1467,29 @@ wss.on('connection', (ws, req) => {
     }
   });
 
-  // Drain check: resume PTY when buffer drops
-  const drainCheck = setInterval(() => {
-    if (paused && ws.bufferedAmount < LOW_WATER) {
-      try { proc.resume(); paused = false; } catch (_) {}
-    }
-  }, 50);
+  const useInMemory = sessionId && !TMUX;
+  const useTmux = TMUX && sessionId;
 
   proc.onExit(() => {
     clearInterval(drainCheck);
-    if (!TMUX || !sessionId) send(0x01, Buffer.from([0]));
+    if (useInMemory) ptySessions.delete(sessionId);
+    if (!useTmux) send(0x01, Buffer.from([0]));
     ws.close();
   });
 
+  // If this is a new in-memory session, register it now (after onExit is wired)
+  if (useInMemory && !rehattached) {
+    ptySessions.set(sessionId, { proc, exited: false, createdAt: Date.now() });
+    // Track exit so stale sessions are detected on reconnect
+    proc.onExit(() => {
+      const entry = ptySessions.get(sessionId);
+      if (entry) entry.exited = true;
+    });
+  } else if (useInMemory && reattached) {
+    const entry = ptySessions.get(sessionId);
+    if (entry) { entry.proc = proc; entry.exited = false; }
+  }
+
   ws.isAlive = true;
   const pingInterval = setInterval(() => {
     if (!ws.isAlive) { clearInterval(pingInterval); ws.terminate(); return; }
@@ -1467,6 +1522,11 @@ wss.on('connection', (ws, req) => {
   const cleanup = () => {
     clearInterval(pingInterval);
     clearInterval(drainCheck);
+    if (useInMemory && sessionId) {
+      // Keep the PTY alive for reattachment — just detach listeners
+      try { proc.removeAllListeners('data'); } catch {}
+      return;
+    }
     try { proc.kill(); } catch {}
   };
   ws.on('close', cleanup);
@@ -1928,6 +1988,11 @@ function cleanup() {
       }
     } catch {}
   }
+  // Kill all in-memory PTY sessions
+  for (const [id, entry] of ptySessions) {
+    try { entry.proc.kill(); } catch {}
+  }
+  ptySessions.clear();
 }
 
 function startServer(opts = {}) {