termbeam 0.0.4 → 0.0.6

package/src/routes.js

@@ -1,6 +1,7 @@
 const path = require('path');
 const os = require('os');
 const fs = require('fs');
+const { detectShells } = require('./shells');
 
 const PUBLIC_DIR = path.join(__dirname, '..', 'public');
 
@@ -46,16 +47,23 @@ function setupRoutes(app, { auth, sessions, config }) {
   });
 
   app.post('/api/sessions', auth.middleware, (req, res) => {
-    const { name, shell, args: shellArgs, cwd } = req.body || {};
+    const { name, shell, args: shellArgs, cwd, initialCommand } = req.body || {};
     const id = sessions.create({
       name: name || `Session ${sessions.sessions.size + 1}`,
       shell: shell || config.defaultShell,
       args: shellArgs || [],
       cwd: cwd || config.cwd,
+      initialCommand: initialCommand || null,
     });
     res.json({ id, url: `/terminal?id=${id}` });
   });
 
+  // Available shells
+  app.get('/api/shells', auth.middleware, (_req, res) => {
+    const shells = detectShells();
+    res.json({ shells, default: config.defaultShell });
+  });
+
   app.delete('/api/sessions/:id', auth.middleware, (req, res) => {
     if (sessions.delete(req.params.id)) {
       res.json({ ok: true });

package/src/sessions.js

@@ -6,7 +6,7 @@ class SessionManager {
     this.sessions = new Map();
   }
 
-  create({ name, shell, args = [], cwd }) {
+  create({ name, shell, args = [], cwd, initialCommand = null }) {
     const id = crypto.randomBytes(4).toString('hex');
     const ptyProcess = pty.spawn(shell, args, {
       name: 'xterm-256color',
@@ -16,6 +16,11 @@ class SessionManager {
       env: { ...process.env, TERM: 'xterm-256color' },
     });
 
+    // Send initial command once the shell is ready
+    if (initialCommand) {
+      setTimeout(() => ptyProcess.write(initialCommand + '\r'), 300);
+    }
+
     const session = {
       pty: ptyProcess,
       name,

package/src/shells.js

@@ -0,0 +1,77 @@
+const os = require('os');
+const fs = require('fs');
+const { execFileSync } = require('child_process');
+
+const KNOWN_WINDOWS_SHELLS = [
+  { name: 'PowerShell (Core)', cmd: 'pwsh.exe' },
+  { name: 'Windows PowerShell', cmd: 'powershell.exe' },
+  { name: 'Command Prompt', cmd: 'cmd.exe' },
+  { name: 'Git Bash', cmd: 'bash.exe' },
+  { name: 'WSL', cmd: 'wsl.exe' },
+];
+
+function detectShells() {
+  if (os.platform() === 'win32') {
+    return detectWindowsShells();
+  }
+  return detectUnixShells();
+}
+
+function detectWindowsShells() {
+  const shells = [];
+  for (const { name, cmd } of KNOWN_WINDOWS_SHELLS) {
+    try {
+      const result = execFileSync('where', [cmd], {
+        stdio: ['pipe', 'pipe', 'ignore'],
+        encoding: 'utf8',
+        timeout: 3000,
+      });
+      const fullPath = result.trim().split('\n')[0].trim();
+      if (fullPath) {
+        shells.push({ name, path: fullPath, cmd });
+      }
+    } catch {
+      // not installed
+    }
+  }
+  return shells;
+}
+
+function detectUnixShells() {
+  const shells = [];
+  const seen = new Set();
+
+  // Read /etc/shells
+  try {
+    const content = fs.readFileSync('/etc/shells', 'utf8');
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith('#')) {
+        const name = trimmed.split('/').pop();
+        if (!seen.has(name)) {
+          seen.add(name);
+          shells.push({ name, path: trimmed, cmd: trimmed });
+        }
+      }
+    }
+  } catch {
+    // /etc/shells not available, try common paths
+    const common = ['/bin/bash', '/bin/zsh', '/bin/sh', '/usr/bin/fish', '/bin/fish'];
+    for (const p of common) {
+      try {
+        fs.accessSync(p, fs.constants.X_OK);
+        const name = p.split('/').pop();
+        if (!seen.has(name)) {
+          seen.add(name);
+          shells.push({ name, path: p, cmd: p });
+        }
+      } catch {
+        // not installed
+      }
+    }
+  }
+
+  return shells;
+}
+
+module.exports = { detectShells };

package/src/tunnel.js

@@ -1,26 +1,79 @@
 const { execSync, spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
 
 let tunnelId = null;
 let tunnelProc = null;
+let devtunnelCmd = 'devtunnel';
+
+function findDevtunnel() {
+  // Try devtunnel directly
+  try {
+    execSync('devtunnel --version', { stdio: 'pipe' });
+    return 'devtunnel';
+  } catch {}
+
+  // On Windows, check common install locations
+  if (process.platform === 'win32') {
+    const candidates = [
+      path.join(process.env.LOCALAPPDATA || '', 'Microsoft', 'WindowsApps', 'devtunnel.exe'),
+      path.join(process.env.PROGRAMFILES || '', 'Microsoft', 'devtunnel', 'devtunnel.exe'),
+    ];
+    for (const p of candidates) {
+      if (fs.existsSync(p)) {
+        return p;
+      }
+    }
+  }
+
+  return null;
+}
 
 async function startTunnel(port) {
+  // Check if devtunnel CLI is installed
+  const found = findDevtunnel();
+  if (!found) {
+    console.error('[termbeam] ❌ devtunnel CLI is not installed.');
+    console.error('');
+    console.error('  The --tunnel flag requires the Azure Dev Tunnels CLI.');
+    console.error('');
+    console.error('  Install it:');
+    console.error('    Windows:  winget install Microsoft.devtunnel');
+    console.error('             or: Invoke-WebRequest -Uri https://aka.ms/TunnelsCliDownload/win-x64 -OutFile devtunnel.exe');
+    console.error('    macOS:    brew install --cask devtunnel');
+    console.error('    Linux:    curl -sL https://aka.ms/DevTunnelCliInstall | bash');
+    console.error('');
+    console.error('  Then restart your terminal and try again.');
+    console.error('  Docs: https://learn.microsoft.com/en-us/azure/developer/dev-tunnels/get-started');
+    console.error('');
+    return null;
+  }
+  devtunnelCmd = found;
+
   console.log('[termbeam] Starting devtunnel...');
   try {
+    // Ensure user is logged in
+    let loggedIn = false;
     try {
-      execSync('devtunnel user show', { stdio: 'pipe' });
-    } catch {
+      const userOut = execSync(`"${devtunnelCmd}" user show`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+      // user show can succeed but show "not logged in" status
+      loggedIn = userOut && !userOut.toLowerCase().includes('not logged in');
+    } catch {}
+
+    if (!loggedIn) {
       console.log('[termbeam] devtunnel not logged in, launching login...');
-      execSync('devtunnel user login -g', { stdio: 'inherit' });
+      console.log('[termbeam] A browser window will open for authentication.');
+      execSync(`"${devtunnelCmd}" user login`, { stdio: 'inherit' });
     }
 
-    const createOut = execSync('devtunnel create --expiration 1d --json', { encoding: 'utf-8' });
+    const createOut = execSync(`"${devtunnelCmd}" 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' });
+    execSync(`"${devtunnelCmd}" port create ${tunnelId} -p ${port} --protocol http`, { stdio: 'pipe' });
+    execSync(`"${devtunnelCmd}" access create ${tunnelId} -p ${port} --anonymous`, { stdio: 'pipe' });
 
-    const hostProc = spawn('devtunnel', ['host', tunnelId], {
+    const hostProc = spawn(devtunnelCmd, ['host', tunnelId], {
       stdio: ['pipe', 'pipe', 'pipe'],
       detached: true,
     });
@@ -56,7 +109,7 @@ function cleanupTunnel() {
   if (tunnelId) {
     try {
       if (tunnelProc) tunnelProc.kill();
-      execSync(`devtunnel delete ${tunnelId} -f`, { stdio: 'pipe' });
+      execSync(`"${devtunnelCmd}" delete ${tunnelId} -f`, { stdio: 'pipe' });
       console.log('[termbeam] Tunnel cleaned up');
     } catch {
       /* best effort */