fix(service): boot persistence and SW auth reliability

Fix pm2 startup hook never being installed — pm2 startup exits 1
by design, so execFileSync threw and the sudo command was lost.
Now parses stdout from the error and passes PATH as a proper
argument to avoid breakage with spaces in PATH.

Fix service worker no-response errors on /api/ routes by removing
the explicit NetworkOnly interception — unmatched requests fall
through to the browser natively.

Fix getConfig localStorage cache poisoning where a stale
no-password cache could bypass auth on a password-protected server.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: dorlugasigal

package.json

@@ -1,6 +1,6 @@
 {
   "name": "termbeam",
-  "version": "1.13.2",
+  "version": "1.13.1",
   "description": "Beam your terminal to any device — mobile-optimized web terminal with multi-session support",
   "main": "src/server/index.js",
   "bin": {

src/cli/service.js

@@ -424,19 +424,62 @@ async function actionInstall() {
   // Run pm2 startup if chosen during wizard
   if (config.startup) {
     console.log('');
-    // pm2 startup outputs a sudo command to copy/paste — capture it and run it
-    const startupOutput = pm2Exec(['startup'], { silent: true }) || '';
+    // pm2 startup outputs a sudo command to copy/paste — but it always exits 1
+    // (since the startup hook isn't installed yet). Extract stdout from the error.
+    let startupOutput = '';
+    try {
+      startupOutput = execFileSync('pm2', ['startup'], {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 15000,
+      });
+    } catch (err) {
+      // pm2 startup exits 1 by design — the sudo command is in stdout
+      startupOutput = (err.stdout || '') + (err.stderr || '');
+    }
     const sudoMatch = startupOutput.match(/^(sudo .+)$/m);
     if (sudoMatch) {
       console.log(dim('Setting up boot persistence (may ask for your password)...\n'));
-      const { spawn } = require('child_process');
-      const child = spawn('sh', ['-c', sudoMatch[1]], { stdio: 'inherit' });
-      await new Promise((resolve) => child.on('close', resolve));
-      pm2Exec(['save'], { inherit: true });
-      console.log(green('✓ TermBeam will start automatically on boot.'));
+      const { spawnSync } = require('child_process');
+      // pm2 outputs: sudo env PATH=$PATH:/extra /path/to/pm2 startup <init> -u <user> --hp <home>
+      // We can't use sh -c because $PATH may contain spaces (e.g. "Visual Studio Code.app").
+      // Instead, parse the structured command and pass PATH via env to avoid shell expansion.
+      const envMatch = sudoMatch[1].match(
+        /^sudo\s+env\s+PATH=\$PATH:([\S]+)\s+(\S+)\s+startup\s+(.+)$/,
+      );
+      let result;
+      if (envMatch) {
+        const extraPath = envMatch[1]; // e.g. /opt/homebrew/.../bin
+        const pm2Bin = envMatch[2]; // e.g. /opt/homebrew/.../pm2
+        const restArgs = envMatch[3].split(/\s+/); // e.g. ['launchd', '-u', 'user', '--hp', '/home']
+        const fullPath = (process.env.PATH || '') + ':' + extraPath;
+        result = spawnSync('sudo', ['env', `PATH=${fullPath}`, pm2Bin, 'startup', ...restArgs], {
+          stdio: 'inherit',
+        });
+      } else {
+        // Fallback: try running via sh with quoted PATH
+        const resolved = sudoMatch[1].replace(/\$PATH/g, `'${process.env.PATH || ''}'`);
+        result = spawnSync('sh', ['-c', resolved], { stdio: 'inherit' });
+      }
+      const code = result.status;
+      if (code === 0) {
+        pm2Exec(['save'], { inherit: true });
+        console.log(green('✓ TermBeam will start automatically on boot.'));
+      } else {
+        console.error(red('\n✗ Failed to set up boot persistence.'));
+        console.log(yellow("  TermBeam is running, but won't auto-start after a reboot."));
+        console.log(yellow('  To fix this, run the following command manually:\n'));
+        console.log(`  ${cyan(sudoMatch[1])}`);
+        console.log(yellow('\n  Then run:'));
+        console.log(`  ${cyan('pm2 save')}\n`);
+      }
     } else {
-      // Fallback: just show what pm2 said
-      console.log(startupOutput);
+      console.error(red('✗ Could not determine boot persistence command.'));
+      console.log(yellow("  TermBeam is running, but won't auto-start after a reboot."));
+      console.log(yellow('  To fix this, run:\n'));
+      console.log(`  ${cyan('pm2 startup')}`);
+      console.log(dim('  …then run the sudo command it outputs, followed by:'));
+      console.log(`  ${cyan('pm2 save')}\n`);
     }
   }
 

src/frontend/src/services/api.ts

@@ -186,17 +186,19 @@ export async function getConfig(): Promise<{ passwordRequired: boolean }> {
     const res = await fetchWithTimeout(`${BASE}/api/config`, { credentials: 'same-origin' });
     const ct = res.headers.get('content-type') || '';
     if (!ct.includes('application/json')) {
-      // Server unreachable or tunnel returning HTML — use cached value
+      // Non-JSON response (e.g. DevTunnel auth HTML) — use cached value if available.
+      // Default to passwordRequired=true (safe: shows login rather than bypassing auth).
       const cached = localStorage.getItem('tb:passwordRequired');
-      return { passwordRequired: cached !== 'false' };
+      return { passwordRequired: cached === null ? true : cached !== 'false' };
     }
     const data = (await res.json()) as { passwordRequired: boolean };
     localStorage.setItem('tb:passwordRequired', String(data.passwordRequired));
     return data;
   } catch {
-    // Network error — fall back to cached value
-    const cached = localStorage.getItem('tb:passwordRequired');
-    return { passwordRequired: cached !== 'false' };
+    // Network error — server may be starting up, SW race, or genuinely down.
+    // Always default to passwordRequired=true (safe default) to prevent a stale
+    // no-password cache from bypassing auth on a password-protected server.
+    return { passwordRequired: true };
   }
 }
 

src/frontend/src/sw.ts

@@ -1,7 +1,7 @@
 /// <reference lib="webworker" />
 import { precacheAndRoute, cleanupOutdatedCaches } from 'workbox-precaching';
 import { registerRoute, NavigationRoute } from 'workbox-routing';
-import { CacheFirst, NetworkFirst, NetworkOnly } from 'workbox-strategies';
+import { CacheFirst, NetworkFirst } from 'workbox-strategies';
 import { ExpirationPlugin } from 'workbox-expiration';
 import { CacheableResponsePlugin } from 'workbox-cacheable-response';
 
@@ -40,8 +40,13 @@ registerRoute(
   }),
 );
 
-// Network-only for API calls — never cache auth or session data
-registerRoute(({ url }) => url.pathname.startsWith('/api/'), new NetworkOnly());
+// Network-only for API calls — never cache auth or session data.
+// Use a fetch event listener instead of registerRoute to avoid workbox
+// wrapping the fetch in a Response handler that can throw "no-response"
+// when the network request fails (e.g. during SW activation race).
+// By not registering a route, unmatched /api/ requests fall through to
+// the browser's native fetch — more resilient than SW interception.
+// (Previously used: registerRoute(({url}) => url.pathname.startsWith('/api/'), new NetworkOnly()));
 
 // Skip waiting and claim clients immediately
 self.addEventListener('install', () => {

test/cli/service.test.js

@@ -939,16 +939,24 @@ describe('actionInstall wizard (via run)', () => {
           execOverride ||
           ((cmd, args) => {
             if (cmd === 'which' || cmd === 'where') return '/usr/bin/pm2\n';
-            if (cmd === 'pm2' && args[0] === 'startup') return startupOutput;
+            // pm2 startup always exits 1 — throw with stdout containing the sudo command
+            if (cmd === 'pm2' && args[0] === 'startup') {
+              const err = new Error('pm2 startup exits 1');
+              err.stdout = startupOutput;
+              err.stderr = '';
+              err.status = 1;
+              throw err;
+            }
             return '';
           }),
         spawn:
           spawnMock ||
           (() => ({
             on: (event, cb) => {
-              if (event === 'close') setImmediate(cb);
+              if (event === 'close') setImmediate(() => cb(0));
             },
           })),
+        spawnSync: spawnMock || (() => ({ status: 0 })),
       },
       readline: {
         createInterface: () => ({