ghostterm 1.3.0 → 2.0.0

package/lib/pty-manager.js

@@ -0,0 +1,336 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const pty = require('node-pty');
+const EventEmitter = require('events');
+
+const MAX_SESSIONS = 4;
+const BUFFER_MAX = 512 * 1024;       // 512KB per session
+const BUFFER_TRIM_TO = 384 * 1024;   // trim to 384KB
+const FLUSH_INTERVAL = 50;           // 50ms output batching
+
+function defaultShell() {
+  if (process.platform === 'win32') {
+    // Use PowerShell if available (more reliable than cmd.exe for conpty)
+    const ps = 'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+    const fs = require('fs');
+    if (fs.existsSync(ps)) return ps;
+    return process.env.COMSPEC || 'cmd.exe';
+  }
+  return process.env.SHELL || '/bin/bash';
+}
+
+function defaultCwd() {
+  const desktop = path.join(os.homedir(), 'Desktop');
+  try {
+    require('fs').accessSync(desktop);
+    return desktop;
+  } catch {
+    return os.homedir();
+  }
+}
+
+class PtySession {
+  constructor(id, cols, rows) {
+    this.id = id;
+    this.cols = cols || 80;
+    this.rows = rows || 24;
+    this.buffer = '';
+    this.bufferSeq = 0;
+    this.ptyProcess = null;
+    this._flushTimer = null;
+    this._pendingOutput = '';
+    this._onOutput = null; // set by manager
+  }
+
+  start() {
+    const shell = defaultShell();
+    const args = [];
+    const env = { ...process.env, TERM: 'xterm-256color' };
+    // Remove Claude Code env vars that prevent nested sessions
+    delete env.CLAUDECODE;
+    delete env.CLAUDE_CODE;
+
+    try {
+      this.ptyProcess = pty.spawn(shell, args, {
+        name: 'xterm-256color',
+        cols: this.cols,
+        rows: this.rows,
+        cwd: defaultCwd(),
+        env,
+      });
+    } catch (e) {
+      console.error('Failed to spawn PTY:', e.message);
+      if (this._onOutput) {
+        this._onOutput(this.id, `\r\n\x1b[31mFailed to start terminal: ${e.message}\x1b[0m\r\n`, null, null);
+        this._onOutput(this.id, null, 1, null);
+      }
+      return;
+    }
+
+    this.ptyProcess.onData((data) => {
+      this.buffer += data;
+      this.bufferSeq += data.length;
+
+      // Trim buffer if too large
+      if (this.buffer.length > BUFFER_MAX) {
+        this.buffer = this.buffer.slice(-BUFFER_TRIM_TO);
+      }
+
+      // Send immediately (like relay version) instead of batching
+      if (this._onOutput) {
+        this._onOutput(this.id, data, null, null);
+      }
+    });
+
+    this.ptyProcess.onExit(({ exitCode, signal }) => {
+      this._flush();
+      if (this._onOutput) {
+        this._onOutput(this.id, null, exitCode, signal);
+      }
+    });
+  }
+
+  _flush() {
+    this._flushTimer = null;
+    if (this._pendingOutput && this._onOutput) {
+      this._onOutput(this.id, this._pendingOutput, null, null);
+      this._pendingOutput = '';
+    }
+  }
+
+  write(data) {
+    if (this.ptyProcess) {
+      this.ptyProcess.write(data);
+    }
+  }
+
+  resize(cols, rows) {
+    this.cols = cols;
+    this.rows = rows;
+    if (this.ptyProcess) {
+      try {
+        this.ptyProcess.resize(cols, rows);
+      } catch {}
+    }
+  }
+
+  kill() {
+    if (this._flushTimer) {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = null;
+    }
+    if (this.ptyProcess) {
+      try {
+        this.ptyProcess.kill();
+      } catch {}
+      this.ptyProcess = null;
+    }
+  }
+}
+
+class PtyManager extends EventEmitter {
+  constructor() {
+    super();
+    this.sessions = new Map(); // id -> PtySession
+    this._nextId = 1;
+    this._attachedId = null;
+  }
+
+  /**
+   * Handle incoming message from mobile client.
+   * Returns response messages to send back.
+   */
+  handleMessage(msg) {
+    const responses = [];
+
+    switch (msg.type) {
+      case 'create-session': {
+        if (this.sessions.size >= MAX_SESSIONS) {
+          responses.push({ type: 'error', message: `Max ${MAX_SESSIONS} sessions` });
+          break;
+        }
+        const id = String(this._nextId++);
+        const session = new PtySession(id, msg.cols || 80, msg.rows || 24);
+        session._onOutput = (sid, data, exitCode, signal) => {
+          if (data !== null) {
+            this.emit('send', { type: 'output', sessionId: sid, data });
+          }
+          if (exitCode !== null || signal !== null) {
+            this.emit('send', { type: 'exit', sessionId: sid, exitCode, signal });
+            this.sessions.delete(sid);
+            if (this._attachedId === sid) {
+              this._attachedId = null;
+            }
+            this._broadcastSessions();
+          }
+        };
+        session.start();
+        this.sessions.set(id, session);
+
+        // Auto-attach to new session
+        this._attachedId = id;
+        responses.push({ type: 'sessions', sessions: this._sessionList() });
+        responses.push({ type: 'attached', sessionId: id });
+
+        // Send initial history if any
+        if (session.buffer) {
+          responses.push({ type: 'history', sessionId: id, data: session.buffer, bufferSeq: session.bufferSeq });
+        }
+        break;
+      }
+
+      case 'close-session': {
+        const id = msg.sessionId || msg.data;
+        const session = this.sessions.get(id);
+        if (session) {
+          session.kill();
+          this.sessions.delete(id);
+          if (this._attachedId === id) {
+            this._attachedId = null;
+          }
+          responses.push({ type: 'exit', sessionId: id, exitCode: 0 });
+          responses.push({ type: 'sessions', sessions: this._sessionList() });
+        }
+        break;
+      }
+
+      case 'attach': {
+        const id = msg.sessionId || msg.data;
+        const session = this.sessions.get(id);
+        if (session) {
+          this._attachedId = id;
+          responses.push({ type: 'attached', sessionId: id });
+          responses.push({ type: 'history', sessionId: id, data: session.buffer, bufferSeq: session.bufferSeq });
+        } else {
+          responses.push({ type: 'error', message: `Session ${id} not found` });
+        }
+        break;
+      }
+
+      case 'sync': {
+        // Delta sync: send only new data since clientSeq (matches relay logic)
+        const session = this.sessions.get(msg.sessionId);
+        if (session) {
+          const clientSeq = msg.clientSeq;
+          const bufStart = session.bufferSeq - session.buffer.length;
+          if (clientSeq >= session.bufferSeq) {
+            // Client is up to date
+            responses.push({
+              type: 'delta',
+              sessionId: msg.sessionId,
+              data: '',
+              bufferSeq: session.bufferSeq,
+            });
+          } else if (clientSeq >= bufStart) {
+            // Client is behind but within buffer range — send slice
+            const offset = clientSeq - bufStart;
+            responses.push({
+              type: 'delta',
+              sessionId: msg.sessionId,
+              data: session.buffer.slice(offset),
+              bufferSeq: session.bufferSeq,
+            });
+          } else {
+            // Client is too far behind — send full buffer as history
+            responses.push({
+              type: 'history',
+              sessionId: msg.sessionId,
+              data: session.buffer,
+              bufferSeq: session.bufferSeq,
+            });
+          }
+        }
+        break;
+      }
+
+      case 'input': {
+        const targetId = msg.sessionId || this._attachedId;
+        const session = targetId ? this.sessions.get(targetId) : null;
+        if (session) {
+          session.write(msg.data);
+        }
+        break;
+      }
+
+      case 'resize': {
+        const targetId = msg.sessionId || this._attachedId;
+        const session = targetId ? this.sessions.get(targetId) : null;
+        if (session && msg.cols && msg.rows) {
+          session.resize(msg.cols, msg.rows);
+        }
+        break;
+      }
+
+      case 'list-sessions': {
+        responses.push({ type: 'sessions', sessions: this._sessionList() });
+        break;
+      }
+
+      case 'file-upload': {
+        // Handle file upload: write base64 content to temp file
+        this._handleFileUpload(msg, responses);
+        break;
+      }
+
+      default:
+        break;
+    }
+
+    return responses;
+  }
+
+  _handleFileUpload(msg, responses) {
+    const fs = require('fs');
+    const tmpDir = os.tmpdir();
+    const filename = msg.filename || `upload_${Date.now()}${msg.ext || ''}`;
+    const filepath = path.join(tmpDir, filename);
+
+    try {
+      const data = Buffer.from(msg.data, 'base64');
+      fs.writeFileSync(filepath, data);
+      responses.push({
+        type: 'file-uploaded',
+        path: filepath,
+        size: data.length,
+      });
+
+      // If attached to a session, optionally paste the path
+      if (msg.pastePath && this._attachedId) {
+        const session = this.sessions.get(this._attachedId);
+        if (session) {
+          session.write(filepath);
+        }
+      }
+    } catch (err) {
+      responses.push({ type: 'error', message: `File upload failed: ${err.message}` });
+    }
+  }
+
+  _sessionList() {
+    const list = [];
+    for (const [id, session] of this.sessions) {
+      list.push({
+        id,
+        cols: session.cols,
+        rows: session.rows,
+        attached: id === this._attachedId,
+      });
+    }
+    return list;
+  }
+
+  _broadcastSessions() {
+    this.emit('send', { type: 'sessions', sessions: this._sessionList() });
+  }
+
+  destroy() {
+    for (const [, session] of this.sessions) {
+      session.kill();
+    }
+    this.sessions.clear();
+  }
+}
+
+module.exports = { PtyManager };

package/lib/webrtc-peer.js

@@ -0,0 +1,193 @@
+'use strict';
+
+const nodeDataChannel = require('node-datachannel');
+const EventEmitter = require('events');
+
+const ICE_SERVERS = [
+  'stun:stun.l.google.com:19302',
+  'stun:stun1.l.google.com:19302',
+];
+
+const HEARTBEAT_INTERVAL = 5000;
+const HEARTBEAT_TIMEOUT = 15000;
+const SEND_BUFFER_HIGH = 1024 * 1024;  // 1MB — pause sending when buffered
+const SEND_BUFFER_LOW = 256 * 1024;    // 256KB — resume sending
+const MAX_MESSAGE_SIZE = 64 * 1024;    // 64KB — chunk large messages
+
+class CompanionWebRTC extends EventEmitter {
+  constructor() {
+    super();
+    this._pc = null;
+    this._dc = null;
+    this._connected = false;
+    this._heartbeatTimer = null;
+    this._lastPong = 0;
+    this._sendSignaling = null; // set externally
+  }
+
+  get isActive() {
+    return this._connected && this._dc !== null;
+  }
+
+  /**
+   * Initialize peer connection and create offer.
+   * @param {Function} sendSignaling - function(msg) to send signaling messages via WS
+   */
+  async initiate(sendSignaling) {
+    this._sendSignaling = sendSignaling;
+
+    this._pc = new nodeDataChannel.PeerConnection('companion', {
+      iceServers: ICE_SERVERS.map(s => s),
+    });
+
+    this._pc.onLocalDescription((sdp, type) => {
+      this._sendSignaling({ type: 'webrtc_offer', sdp, sdpType: type });
+    });
+
+    this._pc.onLocalCandidate((candidate, mid) => {
+      this._sendSignaling({ type: 'webrtc_ice', candidate, mid });
+    });
+
+    this._pc.onStateChange((state) => {
+      this.emit('connectionState', state);
+      if (state === 'failed' || state === 'closed') {
+        this._onDisconnect();
+      }
+    });
+
+    this._pc.onGatheringStateChange((state) => {
+      this.emit('gatheringState', state);
+    });
+
+    // Create DataChannel
+    this._dc = this._pc.createDataChannel('ghostterm', {
+      ordered: true,
+    });
+
+    this._dc.onOpen(() => {
+      this._connected = true;
+      this._lastPong = Date.now();
+      this._startHeartbeat();
+      this.emit('open');
+    });
+
+    this._dc.onClosed(() => {
+      this._onDisconnect();
+    });
+
+    this._dc.onError((err) => {
+      this.emit('error', err);
+    });
+
+    this._dc.onMessage((data) => {
+      this._handleMessage(data);
+    });
+  }
+
+  /**
+   * Handle incoming signaling message from the mobile side.
+   */
+  handleSignaling(msg) {
+    if (!this._pc) return;
+
+    if (msg.type === 'webrtc_answer') {
+      this._pc.setRemoteDescription(msg.sdp, msg.sdpType || 'answer');
+    } else if (msg.type === 'webrtc_ice') {
+      this._pc.addRemoteCandidate(msg.candidate, msg.mid || '0');
+    }
+  }
+
+  /**
+   * Send data over the DataChannel with flow control.
+   * Returns false if buffer is full (backpressure).
+   */
+  send(data) {
+    if (!this._dc || !this._connected) return false;
+    try {
+      // Check backpressure — drop if buffer is overwhelmed
+      const buffered = typeof this._dc.bufferedAmount === 'function'
+        ? this._dc.bufferedAmount() : 0;
+      if (buffered > SEND_BUFFER_HIGH) {
+        return false;
+      }
+
+      const str = typeof data === 'string' ? data : JSON.stringify(data);
+      this._dc.sendMessage(str);
+      return true;
+    } catch (err) {
+      this.emit('error', err);
+      return false;
+    }
+  }
+
+  /**
+   * Close the connection.
+   */
+  close() {
+    this._stopHeartbeat();
+    this._connected = false;
+    if (this._dc) {
+      try { this._dc.close(); } catch {}
+      this._dc = null;
+    }
+    if (this._pc) {
+      try { this._pc.close(); } catch {}
+      this._pc = null;
+    }
+  }
+
+  _handleMessage(raw) {
+    // Handle heartbeat
+    if (raw === '__pong__') {
+      this._lastPong = Date.now();
+      return;
+    }
+    if (raw === '__ping__') {
+      this.send('__pong__');
+      return;
+    }
+
+    try {
+      const msg = JSON.parse(raw);
+      this.emit('message', msg);
+    } catch {
+      // Binary or non-JSON data
+      this.emit('data', raw);
+    }
+  }
+
+  _startHeartbeat() {
+    this._stopHeartbeat();
+    this._heartbeatTimer = setInterval(() => {
+      if (!this._connected) return;
+
+      // Check timeout
+      if (Date.now() - this._lastPong > HEARTBEAT_TIMEOUT) {
+        this.emit('timeout');
+        this._onDisconnect();
+        return;
+      }
+
+      // Send ping
+      try {
+        if (this._dc) this._dc.sendMessage('__ping__');
+      } catch {}
+    }, HEARTBEAT_INTERVAL);
+  }
+
+  _stopHeartbeat() {
+    if (this._heartbeatTimer) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = null;
+    }
+  }
+
+  _onDisconnect() {
+    if (!this._connected) return;
+    this._connected = false;
+    this._stopHeartbeat();
+    this.emit('close');
+  }
+}
+
+module.exports = { CompanionWebRTC };

package/package.json

@@ -1,31 +1,35 @@
 {
   "name": "ghostterm",
-  "version": "1.3.0",
-  "description": "Mobile terminal for Claude Code — control your PC from your phone",
+  "version": "2.0.0",
+  "description": "Control your PC terminal from your phone — direct P2P, no server in between",
   "bin": {
-    "ghostterm": "bin/ghostterm.js"
-  },
-  "scripts": {
-    "start": "node bin/ghostterm.js"
+    "ghostterm": "bin/ghostterm-p2p.js"
   },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "dependencies": {
+    "node-datachannel": "^0.12.0",
     "node-pty": "^1.0.0",
-    "ws": "^8.18.0"
+    "ws": "^8.0.0",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   },
-  "keywords": [
-    "claude-code",
-    "terminal",
-    "mobile",
-    "remote",
-    "ghostterm"
-  ],
-  "author": "GhostTerm",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/user/ghostterm.git"
+    "url": "git+https://github.com/anthropic/ghostterm-p2p.git"
   },
-  "engines": {
-    "node": ">=18"
-  }
+  "keywords": [
+    "terminal",
+    "remote",
+    "p2p",
+    "webrtc",
+    "mobile"
+  ]
 }