ghostterm 1.3.0 → 2.0.1

package/bin/ghostterm-p2p.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+'use strict';
+
+// Prevent crash from node-pty conpty_console_list_agent on Windows background processes
+process.on('uncaughtException', (err) => {
+  if (err.message && err.message.includes('AttachConsole')) {
+    // Ignore — this is a known node-pty issue in background mode
+    return;
+  }
+  console.error('Uncaught error:', err.message);
+});
+
+const WebSocket = require('ws');
+const qrcode = require('qrcode-terminal');
+const { CompanionWebRTC } = require('../lib/webrtc-peer');
+const { PtyManager } = require('../lib/pty-manager');
+const { getToken, saveToken } = require('../lib/auth');
+
+// --- Configuration ---
+const DEFAULT_SIGNALING = 'wss://ghostterm-p2p-signal.fly.dev';
+const SITE_URL = 'https://ghostterm.pages.dev';
+
+const args = process.argv.slice(2);
+const signalingUrl = getArg('--signal', '-s') || DEFAULT_SIGNALING;
+const siteUrl = getArg('--site') || SITE_URL;
+const helpRequested = args.includes('--help') || args.includes('-h');
+
+function getArg(long, short) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === long || (short && args[i] === short)) {
+      return args[i + 1];
+    }
+  }
+  return null;
+}
+
+if (helpRequested) {
+  console.log(`
+  GhostTerm P2P - Control your terminal from your phone via WebRTC
+
+  Usage:
+    npx ghostterm-p2p [options]
+
+  Options:
+    -s, --signal <url>   Signaling server URL (default: ${DEFAULT_SIGNALING})
+    --site <url>         Mobile site URL (default: ${SITE_URL})
+    -h, --help           Show this help
+
+  How it works:
+    1. This tool connects to the signaling server and gets a 6-digit pair code
+    2. Open the mobile site on your phone and enter the code
+    3. A direct P2P WebRTC connection is established
+    4. All terminal data flows directly between your phone and PC (encrypted)
+    5. The signaling server never sees your terminal data
+  `);
+  process.exit(0);
+}
+
+// --- State ---
+let ws = null;
+let webrtc = null;
+let ptyManager = null;
+let pairCode = null;
+let reconnecting = false;
+let authToken = null; // Google or long token
+
+// --- Main ---
+
+async function start() {
+  console.log('\n  GhostTerm P2P');
+  console.log('  =============');
+
+  // Try to get auth token (optional — won't block if no login)
+  try {
+    authToken = await getToken();
+  } catch (e) {
+    console.log('  Skipping login (anonymous mode)');
+    authToken = null;
+  }
+
+  console.log('  Connecting to signaling server...');
+  connectSignaling();
+}
+
+function connectSignaling() {
+  const url = `${signalingUrl}?role=companion`;
+  ws = new WebSocket(url);
+
+  ws.on('open', () => {
+    console.log('  Connected to signaling server.');
+    reconnecting = false;
+    resetReconnectDelay();
+    // Send auth token if available
+    if (authToken) {
+      ws.send(JSON.stringify({ type: 'auth', token: authToken }));
+    }
+  });
+
+  ws.on('message', (raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    handleSignalingMessage(msg);
+  });
+
+  ws.on('close', () => {
+    if (!reconnecting) {
+      console.log('\n  Signaling server disconnected.');
+    }
+    scheduleReconnect();
+  });
+
+  ws.on('error', (err) => {
+    if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') {
+      console.error(`  Cannot reach signaling server at ${signalingUrl}`);
+    }
+  });
+}
+
+function handleSignalingMessage(msg) {
+  switch (msg.type) {
+    case 'pair_code':
+      pairCode = msg.code;
+      displayPairCode(msg.code);
+      break;
+
+    case 'mobile_connected':
+      console.log('\n  Mobile device paired! Establishing P2P connection...');
+      initiateWebRTC();
+      break;
+
+    case 'webrtc_answer':
+    case 'webrtc_ice':
+      if (webrtc) {
+        webrtc.handleSignaling(msg);
+      }
+      break;
+
+    case 'mobile_disconnected':
+      // Ignore if P2P is active — mobile closed signaling WS after P2P established (expected)
+      if (webrtc && webrtc.isActive) {
+        // P2P still alive, signaling disconnect is normal
+        break;
+      }
+      console.log('\n  Mobile disconnected.');
+      cleanupWebRTC();
+      break;
+
+    case 'pair_expired':
+      console.log('\n  Pair code expired. Reconnecting for a new code...');
+      ws.close();
+      break;
+
+    case 'auth_ok':
+      console.log(`  Authenticated as: ${msg.email}`);
+      // Save long token for future sessions
+      if (msg.longToken) {
+        saveToken(null, msg.longToken);
+        authToken = msg.longToken;
+      }
+      break;
+
+    case 'auth_error':
+      console.error(`  Auth failed: ${msg.message}`);
+      break;
+
+    case 'error':
+      console.error(`  Server error: ${msg.message}`);
+      break;
+  }
+}
+
+function displayPairCode(code) {
+  const mobileUrl = `${siteUrl}?code=${code}`;
+
+  console.log('\n  +--------------------------+');
+  console.log(`  |    Pair Code:  ${code}     |`);
+  console.log('  +--------------------------+');
+  console.log(`\n  Or scan QR code with your phone:\n`);
+
+  qrcode.generate(mobileUrl, { small: true }, (qr) => {
+    // Indent each line
+    const lines = qr.split('\n').map(l => '    ' + l).join('\n');
+    console.log(lines);
+    console.log(`\n  Mobile URL: ${mobileUrl}`);
+    console.log('\n  Waiting for phone to connect...\n');
+  });
+}
+
+function initiateWebRTC() {
+  cleanupWebRTC();
+
+  webrtc = new CompanionWebRTC();
+  ptyManager = new PtyManager();
+
+  // Wire PTY output to WebRTC
+  ptyManager.on('send', (msg) => {
+    if (webrtc && webrtc.isActive) {
+      webrtc.send(msg);
+    }
+  });
+
+  // Wire WebRTC messages to PTY
+  webrtc.on('message', (msg) => {
+    if (msg.type === 'shutdown') {
+      console.log('\n  Shutdown requested from mobile. Bye!');
+      cleanupWebRTC();
+      if (ws) ws.close();
+      process.exit(0);
+    }
+    if (msg.type === 'resize') {
+      console.log(`  [resize] cols=${msg.cols} rows=${msg.rows} sid=${msg.sessionId || 'attached'}`);
+    }
+    if (ptyManager) {
+      const responses = ptyManager.handleMessage(msg);
+      for (const resp of responses) {
+        webrtc.send(resp);
+      }
+    }
+  });
+
+  webrtc.on('open', () => {
+    console.log('  P2P connection established! Terminal is now accessible from your phone.');
+    console.log('  All data flows directly between your devices (encrypted).');
+    console.log('  Press Ctrl+C to stop.\n');
+  });
+
+  webrtc.on('close', () => {
+    console.log('\n  P2P connection closed.');
+    cleanupPty();
+    scheduleReconnect();
+  });
+
+  webrtc.on('timeout', () => {
+    console.log('\n  P2P heartbeat timeout. Connection lost.');
+  });
+
+  webrtc.on('error', (err) => {
+    console.error(`  WebRTC error: ${err}`);
+  });
+
+  // Initiate the connection (sends offer via signaling)
+  webrtc.initiate((msg) => {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  });
+}
+
+function cleanupWebRTC() {
+  if (webrtc) {
+    webrtc.removeAllListeners();
+    webrtc.close();
+    webrtc = null;
+  }
+  cleanupPty();
+}
+
+function cleanupPty() {
+  if (ptyManager) {
+    ptyManager.removeAllListeners();
+    ptyManager.destroy();
+    ptyManager = null;
+  }
+}
+
+let reconnectTimer = null;
+let reconnectDelay = 1000; // start at 1s
+const RECONNECT_MAX = 30000; // cap at 30s
+
+function scheduleReconnect() {
+  if (reconnectTimer) return;
+  reconnecting = true;
+  const delay = reconnectDelay;
+  console.log(`  Reconnecting in ${(delay / 1000).toFixed(0)}s...`);
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    connectSignaling();
+  }, delay);
+  // Exponential backoff: 1s → 2s → 4s → 8s → 16s → 30s (capped)
+  reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX);
+}
+
+function resetReconnectDelay() {
+  reconnectDelay = 1000;
+}
+
+// --- Graceful shutdown ---
+
+process.on('SIGINT', () => {
+  console.log('\n  Shutting down...');
+  cleanupWebRTC();
+  if (ws) {
+    ws.close();
+  }
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer);
+  }
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  cleanupWebRTC();
+  if (ws) ws.close();
+  process.exit(0);
+});
+
+// --- Go ---
+start();

package/lib/auth.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const http = require('http');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const { execFile } = require('child_process');
+
+const GOOGLE_CLIENT_ID = '967114885808-9lrt6j05ip65t88sm1rq0foetcu52kdv.apps.googleusercontent.com';
+const CRED_DIR = path.join(os.homedir(), '.ghostterm');
+const CRED_FILE = path.join(CRED_DIR, 'credentials.json');
+
+function loadToken() {
+  try {
+    if (fs.existsSync(CRED_FILE)) {
+      const cred = JSON.parse(fs.readFileSync(CRED_FILE, 'utf8'));
+      if (cred.id_token) {
+        try {
+          const parts = cred.id_token.split('.');
+          if (parts.length >= 2) {
+            const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
+            if (payload.exp && payload.exp * 1000 > Date.now()) {
+              return cred.id_token;
+            }
+          }
+        } catch {}
+        // Long token format (base64.hex) — try it anyway
+        if (cred.id_token.split('.').length === 2) {
+          return cred.id_token;
+        }
+      }
+      if (cred.long_token) {
+        return cred.long_token;
+      }
+    }
+  } catch {}
+  return null;
+}
+
+function saveToken(idToken, longToken) {
+  if (!fs.existsSync(CRED_DIR)) {
+    fs.mkdirSync(CRED_DIR, { recursive: true });
+  }
+  const cred = {};
+  if (idToken) cred.id_token = idToken;
+  if (longToken) cred.long_token = longToken;
+  fs.writeFileSync(CRED_FILE, JSON.stringify(cred, null, 2));
+}
+
+function openBrowser(url) {
+  if (os.platform() === 'win32') {
+    execFile('cmd', ['/c', 'start', '', url]);
+  } else if (os.platform() === 'darwin') {
+    execFile('open', [url]);
+  } else {
+    execFile('xdg-open', [url]);
+  }
+}
+
+function startLoginFlow() {
+  return new Promise((resolve, reject) => {
+    const loginPage = `<!DOCTYPE html>
+<html><head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>GhostTerm P2P - Sign In</title>
+<script src="https://accounts.google.com/gsi/client" async defer></script>
+<style>
+  body { font-family: -apple-system, system-ui, sans-serif; background: #0f0f1a; color: #e2e8f0; display: flex; align-items: center; justify-content: center; min-height: 100vh; margin: 0; }
+  .container { text-align: center; }
+  h1 { color: #8b5cf6; margin-bottom: 8px; }
+  p { color: #94a3b8; margin-bottom: 24px; }
+  #status { margin-top: 20px; color: #10b981; display: none; font-size: 18px; }
+</style>
+</head><body>
+<div class="container">
+  <h1>GhostTerm P2P</h1>
+  <p>Sign in with Google to link your companion</p>
+  <div id="g_id_onload"
+    data-client_id="${GOOGLE_CLIENT_ID}"
+    data-callback="onSignIn"
+    data-auto_select="true">
+  </div>
+  <div class="g_id_signin" data-type="standard" data-size="large" data-theme="filled_black" data-text="signin_with" data-width="300"></div>
+  <div id="status">Login successful! You can close this tab.</div>
+</div>
+<script>
+function onSignIn(response) {
+  fetch('/callback', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ id_token: response.credential })
+  }).then(() => {
+    document.getElementById('status').style.display = 'block';
+    document.querySelector('.g_id_signin').style.display = 'none';
+  });
+}
+</script>
+</body></html>`;
+
+    const loginServer = http.createServer((req, res) => {
+      if (req.method === 'GET' && req.url === '/') {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(loginPage);
+      } else if (req.method === 'POST' && req.url === '/callback') {
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', () => {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end('{"ok":true}');
+          try {
+            const { id_token } = JSON.parse(body);
+            saveToken(id_token);
+            console.log('  Login successful!');
+            setTimeout(() => {
+              loginServer.close();
+              resolve(id_token);
+            }, 500);
+          } catch (e) {
+            reject(e);
+          }
+        });
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+
+    loginServer.listen(3000, () => {
+      console.log('  Opening browser for Google login...');
+      console.log('  If browser does not open, go to: http://localhost:3000');
+      openBrowser('http://localhost:3000');
+    });
+
+    setTimeout(() => {
+      loginServer.close();
+      reject(new Error('Login timeout (2 min)'));
+    }, 120000);
+  });
+}
+
+async function getToken() {
+  let token = loadToken();
+  if (token) {
+    console.log('  Using cached credential');
+    return token;
+  }
+  console.log('  No saved login found. Starting Google Sign-In...');
+  return startLoginFlow();
+}
+
+module.exports = { getToken, saveToken, loadToken };