termbeam 0.0.1

package/src/routes.js

@@ -0,0 +1,87 @@
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const PUBLIC_DIR = path.join(__dirname, '..', 'public');
+
+function setupRoutes(app, { auth, sessions, config }) {
+  // Login page
+  app.get('/login', (_req, res) => {
+    if (!auth.password) return res.redirect('/');
+    res.send(auth.loginHTML);
+  });
+
+  // Auth API
+  app.post('/api/auth', auth.rateLimit, (req, res) => {
+    const { password } = req.body || {};
+    if (password === auth.password) {
+      const token = auth.generateToken();
+      res.cookie('pty_token', token, {
+        httpOnly: true,
+        sameSite: 'lax',
+        maxAge: 24 * 60 * 60 * 1000,
+        secure: false,
+      });
+      res.json({ ok: true });
+    } else {
+      res.status(401).json({ error: 'wrong password' });
+    }
+  });
+
+  // Version API
+  app.get('/api/version', (_req, res) => {
+    const { getVersion } = require('./version');
+    res.json({ version: getVersion() });
+  });
+
+  // Pages
+  app.get('/', auth.middleware, (_req, res) => res.sendFile(path.join(PUBLIC_DIR, 'index.html')));
+  app.get('/terminal', auth.middleware, (_req, res) =>
+    res.sendFile(path.join(PUBLIC_DIR, 'terminal.html')),
+  );
+
+  // Session API
+  app.get('/api/sessions', auth.middleware, (_req, res) => {
+    res.json(sessions.list());
+  });
+
+  app.post('/api/sessions', auth.middleware, (req, res) => {
+    const { name, shell, args: shellArgs, cwd } = req.body || {};
+    const id = sessions.create({
+      name: name || `Session ${sessions.sessions.size + 1}`,
+      shell: shell || config.defaultShell,
+      args: shellArgs || [],
+      cwd: cwd || config.cwd,
+    });
+    res.json({ id, url: `/terminal?id=${id}` });
+  });
+
+  app.delete('/api/sessions/:id', auth.middleware, (req, res) => {
+    if (sessions.delete(req.params.id)) {
+      res.json({ ok: true });
+    } else {
+      res.status(404).json({ error: 'not found' });
+    }
+  });
+
+  // Directory listing for folder browser
+  app.get('/api/dirs', auth.middleware, (req, res) => {
+    const query = req.query.q || os.homedir();
+    const dir = query.endsWith('/') ? query : path.dirname(query);
+    const prefix = query.endsWith('/') ? '' : path.basename(query);
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      const dirs = entries
+        .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
+        .filter((e) => !prefix || e.name.toLowerCase().startsWith(prefix.toLowerCase()))
+        .slice(0, 50)
+        .map((e) => path.join(dir, e.name));
+      res.json({ base: dir, dirs });
+    } catch {
+      res.json({ base: dir, dirs: [] });
+    }
+  });
+}
+
+module.exports = { setupRoutes };

package/src/server.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+const os = require('os');
+const path = require('path');
+const express = require('express');
+const cookieParser = require('cookie-parser');
+const http = require('http');
+const { WebSocketServer } = require('ws');
+const QRCode = require('qrcode');
+
+const { parseArgs } = require('./cli');
+const { createAuth } = require('./auth');
+const { SessionManager } = require('./sessions');
+const { setupRoutes } = require('./routes');
+const { setupWebSocket } = require('./websocket');
+const { startTunnel, cleanupTunnel } = require('./tunnel');
+
+// --- Config ---
+const config = parseArgs();
+const auth = createAuth(config.password);
+const sessions = new SessionManager();
+
+// --- Express ---
+const app = express();
+app.use(express.json());
+app.use(cookieParser());
+app.use((_req, res, next) => {
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('X-Frame-Options', 'DENY');
+  res.setHeader('X-XSS-Protection', '1; mode=block');
+  res.setHeader('Referrer-Policy', 'no-referrer');
+  next();
+});
+
+const server = http.createServer(app);
+const wss = new WebSocketServer({ server, path: '/ws' });
+
+setupRoutes(app, { auth, sessions, config });
+setupWebSocket(wss, { auth, sessions });
+
+// --- Lifecycle ---
+function shutdown() {
+  console.log('\n[termbeam] Shutting down...');
+  sessions.shutdown();
+  cleanupTunnel();
+  process.exit(0);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+process.on('uncaughtException', (err) => {
+  console.error('[termbeam] Uncaught exception:', err.message);
+  cleanupTunnel();
+  process.exit(1);
+});
+process.on('exit', cleanupTunnel);
+
+// --- Start ---
+function getLocalIP() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      if (iface.family === 'IPv4' && !iface.internal) return iface.address;
+    }
+  }
+  return '127.0.0.1';
+}
+
+server.listen(config.port, config.host, async () => {
+  const ip = getLocalIP();
+  const localUrl = `http://${ip}:${config.port}`;
+
+  const defaultId = sessions.create({
+    name: path.basename(config.cwd),
+    shell: config.shell,
+    args: config.shellArgs,
+    cwd: config.cwd,
+  });
+
+  console.log('');
+  console.log('  ████████╗███████╗██████╗ ███╗   ███╗██████╗ ███████╗ █████╗ ███╗   ███╗');
+  console.log('  ╚══██╔══╝██╔════╝██╔══██╗████╗ ████║██╔══██╗██╔════╝██╔══██╗████╗ ████║');
+  console.log('     ██║   █████╗  ██████╔╝██╔████╔██║██████╔╝█████╗  ███████║██╔████╔██║');
+  console.log('     ██║   ██╔══╝  ██╔══██╗██║╚██╔╝██║██╔══██╗██╔══╝  ██╔══██║██║╚██╔╝██║');
+  console.log('     ██║   ███████╗██║  ██║██║ ╚═╝ ██║██████╔╝███████╗██║  ██║██║ ╚═╝ ██║');
+  console.log('     ╚═╝   ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═════╝ ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝');
+  console.log('');
+  console.log(`  Beam your terminal to any device 📡  v${config.version}`);
+  console.log('');
+  console.log(`  Local:    http://localhost:${config.port}`);
+  const isLanReachable = config.host === '0.0.0.0' || config.host === '::' || config.host === ip;
+  if (isLanReachable) {
+    console.log(`  LAN:      ${localUrl}`);
+  }
+  console.log(`  Shell:    ${config.shell}`);
+  console.log(`  Session:  ${defaultId}`);
+  console.log(`  Auth:     ${config.password ? '🔒 password' : '🔓 none'}`);
+
+  let publicUrl = null;
+  if (config.useTunnel) {
+    publicUrl = await startTunnel(config.port);
+    if (publicUrl) {
+      console.log('');
+      console.log(`  🌐 Public:  ${publicUrl}`);
+    } else {
+      console.log('');
+      console.log('  ⚠️  Tunnel failed to start. Using LAN only.');
+    }
+  }
+
+  const qrUrl = publicUrl || (isLanReachable ? localUrl : `http://localhost:${config.port}`);
+  console.log('');
+  try {
+    const qr = await QRCode.toString(qrUrl, { type: 'terminal', small: true });
+    console.log(qr);
+  } catch {
+    /* ignore */
+  }
+
+  console.log(`  Scan the QR code or open: ${qrUrl}`);
+  if (config.password) console.log(`  Password: ${config.password}`);
+  console.log('');
+});

package/src/sessions.js

@@ -0,0 +1,90 @@
+const crypto = require('crypto');
+const pty = require('node-pty');
+
+class SessionManager {
+  constructor() {
+    this.sessions = new Map();
+  }
+
+  create({ name, shell, args = [], cwd }) {
+    const id = crypto.randomBytes(4).toString('hex');
+    const ptyProcess = pty.spawn(shell, args, {
+      name: 'xterm-256color',
+      cols: 120,
+      rows: 30,
+      cwd,
+      env: { ...process.env, TERM: 'xterm-256color' },
+    });
+
+    const session = {
+      pty: ptyProcess,
+      name,
+      shell,
+      cwd,
+      createdAt: new Date().toISOString(),
+      clients: new Set(),
+      scrollback: [],
+    };
+
+    ptyProcess.onData((data) => {
+      session.scrollback.push(data);
+      if (session.scrollback.length > 2000) session.scrollback.shift();
+      for (const ws of session.clients) {
+        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'output', data }));
+      }
+    });
+
+    ptyProcess.onExit(({ exitCode }) => {
+      console.log(`[termbeam] Session "${name}" (${id}) exited (code ${exitCode})`);
+      for (const ws of session.clients) {
+        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'exit', code: exitCode }));
+      }
+      this.sessions.delete(id);
+    });
+
+    this.sessions.set(id, session);
+    console.log(`[termbeam] Session "${name}" created (id=${id}, pid=${ptyProcess.pid})`);
+    return id;
+  }
+
+  get(id) {
+    return this.sessions.get(id);
+  }
+
+  delete(id) {
+    const s = this.sessions.get(id);
+    if (!s) return false;
+    s.pty.kill();
+    this.sessions.delete(id);
+    return true;
+  }
+
+  list() {
+    const list = [];
+    for (const [id, s] of this.sessions) {
+      list.push({
+        id,
+        name: s.name,
+        cwd: s.cwd,
+        shell: s.shell,
+        pid: s.pty.pid,
+        clients: s.clients.size,
+        createdAt: s.createdAt,
+      });
+    }
+    return list;
+  }
+
+  shutdown() {
+    for (const [id, s] of this.sessions) {
+      try {
+        s.pty.kill();
+      } catch {
+        /* ignore */
+      }
+    }
+    this.sessions.clear();
+  }
+}
+
+module.exports = { SessionManager };

package/src/tunnel.js

@@ -0,0 +1,69 @@
+const { execSync, spawn } = require('child_process');
+
+let tunnelId = null;
+let tunnelProc = null;
+
+async function startTunnel(port) {
+  console.log('[termbeam] Starting devtunnel...');
+  try {
+    try {
+      execSync('devtunnel user show', { stdio: 'pipe' });
+    } catch {
+      console.log('[termbeam] devtunnel not logged in, launching login...');
+      execSync('devtunnel user login -g', { stdio: 'inherit' });
+    }
+
+    const createOut = execSync('devtunnel create --expiration 1d --json', { encoding: 'utf-8' });
+    const tunnelData = JSON.parse(createOut);
+    tunnelId = tunnelData.tunnel.tunnelId;
+
+    execSync(`devtunnel port create ${tunnelId} -p ${port} --protocol http`, { stdio: 'pipe' });
+    execSync(`devtunnel access create ${tunnelId} -p ${port} --anonymous`, { stdio: 'pipe' });
+
+    const hostProc = spawn('devtunnel', ['host', tunnelId], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true,
+    });
+    tunnelProc = hostProc;
+
+    return new Promise((resolve) => {
+      let output = '';
+      const timeout = setTimeout(() => resolve(null), 15000);
+
+      hostProc.stdout.on('data', (data) => {
+        output += data.toString();
+        const match = output.match(/(https:\/\/[^\s]+devtunnels\.ms[^\s]*)/);
+        if (match) {
+          clearTimeout(timeout);
+          resolve(match[1]);
+        }
+      });
+      hostProc.stderr.on('data', (data) => {
+        output += data.toString();
+      });
+      hostProc.on('error', () => {
+        clearTimeout(timeout);
+        resolve(null);
+      });
+    });
+  } catch (e) {
+    console.error(`[termbeam] Tunnel error: ${e.message}`);
+    return null;
+  }
+}
+
+function cleanupTunnel() {
+  if (tunnelId) {
+    try {
+      if (tunnelProc) tunnelProc.kill();
+      execSync(`devtunnel delete ${tunnelId} -f`, { stdio: 'pipe' });
+      console.log('[termbeam] Tunnel cleaned up');
+    } catch {
+      /* best effort */
+    }
+    tunnelId = null;
+    tunnelProc = null;
+  }
+}
+
+module.exports = { startTunnel, cleanupTunnel };

package/src/version.js

@@ -0,0 +1,34 @@
+const path = require('path');
+const { execSync } = require('child_process');
+
+function getVersion() {
+  const pkg = require(path.join(__dirname, '..', 'package.json'));
+  const base = pkg.version;
+
+  // If installed via npm (global or npx), use the package version as-is
+  if (process.env.npm_package_version || isInstalledGlobally()) {
+    return base;
+  }
+
+  // Running from source — try git describe for a dev version
+  try {
+    const gitDesc = execSync('git describe --tags --always --dirty', {
+      cwd: path.join(__dirname, '..'),
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    // If we have a tag like v1.0.0, and we're exactly on it, return base
+    if (gitDesc === `v${base}`) return base;
+    // Otherwise return dev version
+    return `${base}-dev (${gitDesc})`;
+  } catch {
+    return `${base}-dev`;
+  }
+}
+
+function isInstalledGlobally() {
+  // Check if we're running from a node_modules path (npm/npx install)
+  return __dirname.includes('node_modules');
+}
+
+module.exports = { getVersion };

package/src/websocket.js

@@ -0,0 +1,72 @@
+function setupWebSocket(wss, { auth, sessions }) {
+  wss.on('connection', (ws, req) => {
+    let authenticated = !auth.password;
+    let attached = null;
+
+    // Check cookie from upgrade request
+    if (auth.password) {
+      const cookies = auth.parseCookies(req.headers.cookie || '');
+      if (cookies.pty_token && auth.validateToken(cookies.pty_token)) {
+        authenticated = true;
+      }
+    }
+
+    ws.on('message', (raw) => {
+      try {
+        const msg = JSON.parse(raw);
+
+        if (msg.type === 'auth') {
+          if (msg.password === auth.password || auth.validateToken(msg.token)) {
+            authenticated = true;
+            ws.send(JSON.stringify({ type: 'auth_ok' }));
+          } else {
+            ws.send(JSON.stringify({ type: 'error', message: 'Unauthorized' }));
+            ws.close();
+          }
+          return;
+        }
+
+        if (!authenticated) {
+          ws.send(JSON.stringify({ type: 'error', message: 'Unauthorized' }));
+          ws.close();
+          return;
+        }
+
+        if (msg.type === 'attach') {
+          const session = sessions.get(msg.sessionId);
+          if (!session) {
+            ws.send(JSON.stringify({ type: 'error', message: 'Session not found' }));
+            return;
+          }
+          attached = session;
+          session.clients.add(ws);
+          if (session.scrollback.length > 0) {
+            ws.send(JSON.stringify({ type: 'output', data: session.scrollback.join('') }));
+          }
+          ws.send(JSON.stringify({ type: 'attached', sessionId: msg.sessionId }));
+          console.log(`[termbeam] Client attached to session ${msg.sessionId}`);
+          return;
+        }
+
+        if (!attached) return;
+
+        if (msg.type === 'input') {
+          attached.pty.write(msg.data);
+        } else if (msg.type === 'resize') {
+          attached.pty.resize(msg.cols, msg.rows);
+        }
+      } catch {
+        if (attached) attached.pty.write(raw.toString());
+      }
+    });
+
+    ws.on('close', () => {
+      if (attached) {
+        attached.clients.delete(ws);
+        console.log('[termbeam] Client detached');
+      }
+    });
+  });
+}
+
+module.exports = { setupWebSocket };