nikcli-remote 1.0.0

package/src/server.ts

@@ -0,0 +1,562 @@
+/**
+ * @nikcli/remote - Native Remote Server
+ * WebSocket-based remote terminal with mobile-friendly web client
+ */
+
+import { EventEmitter } from 'node:events'
+import { createServer, type Server, type IncomingMessage, type ServerResponse } from 'node:http'
+import { WebSocketServer, WebSocket } from 'ws'
+import crypto from 'node:crypto'
+import os from 'node:os'
+import type {
+  ServerConfig,
+  RemoteSession,
+  DeviceInfo,
+  BroadcastMessage,
+  RemoteNotification,
+  ClientConnection,
+  ClientMessage,
+  TunnelProvider,
+} from './types'
+import { DEFAULT_CONFIG, MessageTypes } from './types'
+import { TerminalManager } from './terminal'
+import { TunnelManager } from './tunnel'
+import { getWebClient } from './web-client'
+
+export interface RemoteServerEvents {
+  started: (session: RemoteSession) => void
+  stopped: () => void
+  'client:connected': (device: DeviceInfo) => void
+  'client:disconnected': (device: DeviceInfo) => void
+  'client:error': (clientId: string, error: Error) => void
+  'tunnel:connected': (url: string) => void
+  'tunnel:error': (error: Error) => void
+  command: (cmd: { clientId: string; command: string; args?: string[] }) => void
+  message: (client: ClientConnection, message: ClientMessage) => void
+  error: (error: Error) => void
+}
+
+export class RemoteServer extends EventEmitter {
+  private config: ServerConfig
+  private httpServer: Server | null = null
+  private wss: WebSocketServer | null = null
+  private clients: Map<string, ClientConnection & { ws: WebSocket }> = new Map()
+  private session: RemoteSession | null = null
+  private terminal: TerminalManager | null = null
+  private tunnel: TunnelManager | null = null
+  private heartbeatTimer: NodeJS.Timeout | null = null
+  private sessionTimeoutTimer: NodeJS.Timeout | null = null
+  private isRunning = false
+  private sessionSecret: string
+
+  constructor(config: Partial<ServerConfig> = {}) {
+    super()
+    this.config = { ...DEFAULT_CONFIG, ...config }
+    this.sessionSecret = config.sessionSecret || this.generateSecret()
+  }
+
+  /**
+   * Start the remote server
+   */
+  async start(options: { name?: string } = {}): Promise<RemoteSession> {
+    if (this.isRunning) {
+      throw new Error('Server already running')
+    }
+
+    const sessionId = this.generateSessionId()
+
+    // Create HTTP server
+    this.httpServer = createServer((req, res) => this.handleHttpRequest(req, res))
+
+    // Create WebSocket server
+    this.wss = new WebSocketServer({ server: this.httpServer })
+    this.setupWebSocketHandlers()
+
+    // Start listening
+    const port = await new Promise<number>((resolve, reject) => {
+      this.httpServer!.listen(this.config.port, this.config.host, () => {
+        const addr = this.httpServer!.address()
+        resolve(typeof addr === 'object' ? addr?.port || 0 : 0)
+      })
+      this.httpServer!.on('error', reject)
+    })
+
+    // Get local URL
+    const localIp = this.getLocalIP()
+    const localUrl = `http://${localIp}:${port}`
+
+    // Create initial session
+    this.session = {
+      id: sessionId,
+      name: options.name || `nikcli-${sessionId}`,
+      qrCode: '',
+      qrUrl: localUrl,
+      localUrl,
+      status: 'starting',
+      connectedDevices: [],
+      startedAt: new Date(),
+      lastActivity: new Date(),
+      port,
+    }
+
+    // Create tunnel if enabled
+    if (this.config.enableTunnel && this.config.tunnelProvider !== 'none') {
+      try {
+        this.tunnel = new TunnelManager(this.config.tunnelProvider)
+        const tunnelUrl = await this.tunnel.create(port)
+        this.session.tunnelUrl = tunnelUrl
+        this.session.qrUrl = `${tunnelUrl}?s=${sessionId}&t=${this.sessionSecret}`
+        this.emit('tunnel:connected', tunnelUrl)
+      } catch (error: any) {
+        this.emit('tunnel:error', error)
+        // Continue with local URL
+        this.session.qrUrl = `${localUrl}?s=${sessionId}&t=${this.sessionSecret}`
+      }
+    } else {
+      this.session.qrUrl = `${localUrl}?s=${sessionId}&t=${this.sessionSecret}`
+    }
+
+    // Initialize terminal if enabled
+    if (this.config.enableTerminal) {
+      this.terminal = new TerminalManager({
+        shell: this.config.shell,
+        cols: this.config.cols,
+        rows: this.config.rows,
+        cwd: this.config.cwd,
+        env: this.config.env,
+      })
+
+      this.terminal.on('data', (data: string) => {
+        this.broadcast({ type: MessageTypes.TERMINAL_OUTPUT, payload: { data } })
+      })
+
+      this.terminal.on('exit', (code: number) => {
+        this.broadcast({ type: MessageTypes.TERMINAL_EXIT, payload: { code } })
+      })
+    }
+
+    // Start heartbeat
+    this.startHeartbeat()
+
+    // Start session timeout if configured
+    if (this.config.sessionTimeout > 0) {
+      this.startSessionTimeout()
+    }
+
+    this.session.status = 'waiting'
+    this.isRunning = true
+    this.emit('started', this.session)
+
+    return this.session
+  }
+
+  /**
+   * Stop the server
+   */
+  async stop(): Promise<void> {
+    if (!this.isRunning) return
+
+    this.isRunning = false
+
+    // Clear timers
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = null
+    }
+    if (this.sessionTimeoutTimer) {
+      clearTimeout(this.sessionTimeoutTimer)
+      this.sessionTimeoutTimer = null
+    }
+
+    // Notify clients
+    this.broadcast({ type: MessageTypes.SESSION_END, payload: {} })
+
+    // Close all connections
+    for (const client of this.clients.values()) {
+      client.ws.close(1000, 'Server shutting down')
+    }
+    this.clients.clear()
+
+    // Stop terminal
+    if (this.terminal) {
+      this.terminal.destroy()
+      this.terminal = null
+    }
+
+    // Stop tunnel
+    if (this.tunnel) {
+      await this.tunnel.close()
+      this.tunnel = null
+    }
+
+    // Close WebSocket server
+    if (this.wss) {
+      this.wss.close()
+      this.wss = null
+    }
+
+    // Close HTTP server
+    if (this.httpServer) {
+      await new Promise<void>((resolve) => {
+        this.httpServer!.close(() => resolve())
+      })
+      this.httpServer = null
+    }
+
+    if (this.session) {
+      this.session.status = 'stopped'
+    }
+
+    this.emit('stopped')
+  }
+
+  /**
+   * Broadcast message to all authenticated clients
+   */
+  broadcast(message: BroadcastMessage): void {
+    const data = JSON.stringify({
+      type: message.type,
+      payload: message.payload,
+      timestamp: message.timestamp || Date.now(),
+    })
+
+    for (const client of this.clients.values()) {
+      if (client.authenticated && client.ws.readyState === WebSocket.OPEN) {
+        client.ws.send(data)
+      }
+    }
+  }
+
+  /**
+   * Send notification to clients
+   */
+  notify(notification: RemoteNotification): void {
+    this.broadcast({
+      type: MessageTypes.NOTIFICATION,
+      payload: notification,
+    })
+  }
+
+  /**
+   * Get current session
+   */
+  getSession(): RemoteSession | null {
+    return this.session
+  }
+
+  /**
+   * Check if server is running
+   */
+  isActive(): boolean {
+    return this.isRunning && this.session?.status !== 'stopped'
+  }
+
+  /**
+   * Get connected client count
+   */
+  getConnectedCount(): number {
+    let count = 0
+    for (const client of this.clients.values()) {
+      if (client.authenticated) count++
+    }
+    return count
+  }
+
+  /**
+   * Write to terminal
+   */
+  writeToTerminal(data: string): void {
+    this.terminal?.write(data)
+  }
+
+  /**
+   * Resize terminal
+   */
+  resizeTerminal(cols: number, rows: number): void {
+    this.terminal?.resize(cols, rows)
+  }
+
+  /**
+   * Setup WebSocket handlers
+   */
+  private setupWebSocketHandlers(): void {
+    this.wss!.on('connection', (ws, req) => {
+      const clientId = this.generateClientId()
+
+      const client: ClientConnection & { ws: WebSocket } = {
+        id: clientId,
+        ws,
+        authenticated: false,
+        device: {
+          id: clientId,
+          userAgent: req.headers['user-agent'],
+          ip: req.socket.remoteAddress,
+          connectedAt: new Date(),
+          lastActivity: new Date(),
+        },
+        lastPing: Date.now(),
+      }
+
+      // Check max connections
+      if (this.clients.size >= this.config.maxConnections) {
+        ws.close(1013, 'Max connections reached')
+        return
+      }
+
+      this.clients.set(clientId, client)
+
+      // Request auth
+      ws.send(JSON.stringify({ type: MessageTypes.AUTH_REQUIRED, timestamp: Date.now() }))
+
+      ws.on('message', (data) => {
+        try {
+          const message: ClientMessage = JSON.parse(data.toString())
+          this.handleClientMessage(client, message)
+        } catch {
+          // Invalid JSON, ignore
+        }
+      })
+
+      ws.on('close', () => {
+        this.clients.delete(clientId)
+        if (this.session && client.authenticated) {
+          this.session.connectedDevices = this.session.connectedDevices.filter(
+            (d) => d.id !== clientId
+          )
+          if (this.session.connectedDevices.length === 0) {
+            this.session.status = 'waiting'
+          }
+          this.emit('client:disconnected', client.device)
+        }
+      })
+
+      ws.on('error', (error) => {
+        this.emit('client:error', clientId, error)
+      })
+
+      ws.on('pong', () => {
+        client.lastPing = Date.now()
+      })
+    })
+  }
+
+  /**
+   * Handle client message
+   */
+  private handleClientMessage(
+    client: ClientConnection & { ws: WebSocket },
+    message: ClientMessage
+  ): void {
+    client.device.lastActivity = new Date()
+    if (this.session) {
+      this.session.lastActivity = new Date()
+    }
+
+    // Reset session timeout
+    if (this.config.sessionTimeout > 0) {
+      this.resetSessionTimeout()
+    }
+
+    switch (message.type) {
+      case MessageTypes.AUTH:
+        this.handleAuth(client, message.token as string)
+        break
+
+      case MessageTypes.TERMINAL_INPUT:
+        if (client.authenticated && message.data) {
+          this.terminal?.write(message.data as string)
+        }
+        break
+
+      case MessageTypes.TERMINAL_RESIZE:
+        if (client.authenticated && message.cols && message.rows) {
+          this.terminal?.resize(message.cols as number, message.rows as number)
+        }
+        break
+
+      case MessageTypes.TERMINAL_CLEAR:
+        if (client.authenticated) {
+          this.terminal?.clear()
+        }
+        break
+
+      case MessageTypes.PING:
+        client.ws.send(JSON.stringify({ type: MessageTypes.PONG, timestamp: Date.now() }))
+        break
+
+      case MessageTypes.COMMAND:
+        if (client.authenticated) {
+          this.emit('command', {
+            clientId: client.id,
+            command: message.command as string,
+            args: message.args as string[] | undefined,
+          })
+        }
+        break
+
+      default:
+        this.emit('message', client, message)
+    }
+  }
+
+  /**
+   * Handle authentication
+   */
+  private handleAuth(client: ClientConnection & { ws: WebSocket }, token: string): void {
+    if (token === this.sessionSecret) {
+      client.authenticated = true
+
+      if (this.session) {
+        this.session.connectedDevices.push(client.device)
+        this.session.status = 'connected'
+      }
+
+      client.ws.send(
+        JSON.stringify({
+          type: MessageTypes.AUTH_SUCCESS,
+          payload: {
+            sessionId: this.session?.id,
+            terminalEnabled: this.config.enableTerminal,
+          },
+          timestamp: Date.now(),
+        })
+      )
+
+      // Start terminal if needed
+      if (this.config.enableTerminal && !this.terminal?.isRunning()) {
+        this.terminal?.start()
+      }
+
+      this.emit('client:connected', client.device)
+    } else {
+      client.ws.send(JSON.stringify({ type: MessageTypes.AUTH_FAILED, timestamp: Date.now() }))
+      setTimeout(() => client.ws.close(1008, 'Authentication failed'), 100)
+    }
+  }
+
+  /**
+   * Handle HTTP request
+   */
+  private handleHttpRequest(req: IncomingMessage, res: ServerResponse): void {
+    const url = new URL(req.url || '/', `http://${req.headers.host}`)
+    const path = url.pathname
+
+    // CORS headers
+    res.setHeader('Access-Control-Allow-Origin', '*')
+    res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS')
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type')
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204)
+      res.end()
+      return
+    }
+
+    // Serve web client
+    if (path === '/' || path === '/index.html') {
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
+      res.end(getWebClient())
+      return
+    }
+
+    // Health check
+    if (path === '/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ status: 'ok', session: this.session?.id }))
+      return
+    }
+
+    // Session info
+    if (path === '/api/session') {
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(
+        JSON.stringify({
+          id: this.session?.id,
+          name: this.session?.name,
+          status: this.session?.status,
+          connectedDevices: this.session?.connectedDevices.length,
+        })
+      )
+      return
+    }
+
+    res.writeHead(404, { 'Content-Type': 'text/plain' })
+    res.end('Not Found')
+  }
+
+  /**
+   * Start heartbeat
+   */
+  private startHeartbeat(): void {
+    this.heartbeatTimer = setInterval(() => {
+      const now = Date.now()
+      for (const [id, client] of this.clients) {
+        if (now - client.lastPing > this.config.heartbeatInterval * 2) {
+          client.ws.terminate()
+          this.clients.delete(id)
+        } else if (client.ws.readyState === WebSocket.OPEN) {
+          client.ws.ping()
+        }
+      }
+    }, this.config.heartbeatInterval)
+  }
+
+  /**
+   * Start session timeout
+   */
+  private startSessionTimeout(): void {
+    this.sessionTimeoutTimer = setTimeout(() => {
+      if (this.session?.connectedDevices.length === 0) {
+        this.stop()
+      }
+    }, this.config.sessionTimeout)
+  }
+
+  /**
+   * Reset session timeout
+   */
+  private resetSessionTimeout(): void {
+    if (this.sessionTimeoutTimer) {
+      clearTimeout(this.sessionTimeoutTimer)
+    }
+    if (this.config.sessionTimeout > 0) {
+      this.startSessionTimeout()
+    }
+  }
+
+  /**
+   * Get local IP
+   */
+  private getLocalIP(): string {
+    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'
+  }
+
+  /**
+   * Generate session ID
+   */
+  private generateSessionId(): string {
+    return crypto.randomBytes(4).toString('hex')
+  }
+
+  /**
+   * Generate client ID
+   */
+  private generateClientId(): string {
+    return 'c_' + crypto.randomBytes(4).toString('hex')
+  }
+
+  /**
+   * Generate secret
+   */
+  private generateSecret(): string {
+    return crypto.randomBytes(16).toString('hex')
+  }
+}

package/src/terminal.ts

@@ -0,0 +1,163 @@
+/**
+ * @nikcli/remote - Terminal Manager
+ * PTY-based terminal with fallback to basic spawn
+ */
+
+import { EventEmitter } from 'node:events'
+import { spawn, type ChildProcess } from 'node:child_process'
+
+// Try to import node-pty
+let pty: typeof import('node-pty') | null = null
+try {
+  pty = require('node-pty')
+} catch {
+  // node-pty not available
+}
+
+export interface TerminalConfig {
+  shell: string
+  cols: number
+  rows: number
+  cwd?: string
+  env?: Record<string, string>
+}
+
+export class TerminalManager extends EventEmitter {
+  private config: TerminalConfig
+  private ptyProcess: any = null
+  private process: ChildProcess | null = null
+  private running = false
+
+  constructor(config: TerminalConfig) {
+    super()
+    this.config = config
+  }
+
+  /**
+   * Start the terminal
+   */
+  start(): void {
+    if (this.running) return
+
+    const { shell, cols, rows, cwd, env } = this.config
+    const termEnv = {
+      ...process.env,
+      ...env,
+      TERM: 'xterm-256color',
+      COLORTERM: 'truecolor',
+    }
+
+    if (pty) {
+      // Use node-pty for full terminal emulation
+      try {
+        this.ptyProcess = pty.spawn(shell, [], {
+          name: 'xterm-256color',
+          cols,
+          rows,
+          cwd: cwd || process.cwd(),
+          env: termEnv,
+        })
+
+        this.ptyProcess.onData((data: string) => {
+          this.emit('data', data)
+        })
+
+        this.ptyProcess.onExit(({ exitCode }: { exitCode: number }) => {
+          this.running = false
+          this.emit('exit', exitCode)
+        })
+
+        this.running = true
+        return
+      } catch (error: any) {
+        // Fall through to basic spawn
+        console.warn('node-pty failed, using fallback:', error.message)
+      }
+    }
+
+    // Fallback to basic spawn
+    this.process = spawn(shell, [], {
+      cwd: cwd || process.cwd(),
+      env: termEnv,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: true,
+    })
+
+    this.process.stdout?.on('data', (data: Buffer) => {
+      this.emit('data', data.toString())
+    })
+
+    this.process.stderr?.on('data', (data: Buffer) => {
+      this.emit('data', data.toString())
+    })
+
+    this.process.on('exit', (code) => {
+      this.running = false
+      this.emit('exit', code || 0)
+    })
+
+    this.process.on('error', (error) => {
+      this.emit('error', error)
+    })
+
+    this.running = true
+  }
+
+  /**
+   * Write data to terminal
+   */
+  write(data: string): void {
+    if (this.ptyProcess) {
+      this.ptyProcess.write(data)
+    } else if (this.process?.stdin) {
+      this.process.stdin.write(data)
+    }
+  }
+
+  /**
+   * Resize terminal
+   */
+  resize(cols: number, rows: number): void {
+    if (this.ptyProcess) {
+      this.ptyProcess.resize(cols, rows)
+    }
+    // Basic spawn doesn't support resize
+  }
+
+  /**
+   * Clear terminal
+   */
+  clear(): void {
+    // Send clear screen escape sequence
+    this.emit('data', '\x1b[2J\x1b[H')
+  }
+
+  /**
+   * Kill terminal process
+   */
+  destroy(): void {
+    this.running = false
+    if (this.ptyProcess) {
+      this.ptyProcess.kill()
+      this.ptyProcess = null
+    }
+    if (this.process) {
+      this.process.kill()
+      this.process = null
+    }
+  }
+
+  /**
+   * Check if terminal is running
+   */
+  isRunning(): boolean {
+    return this.running
+  }
+
+  /**
+   * Check if using PTY
+   */
+  hasPty(): boolean {
+    return this.ptyProcess !== null
+  }
+}