nikcli-remote 1.0.9 → 1.0.11

package/src/server.ts

@@ -1,11 +1,11 @@
 /**
- * @nikcli/remote - Native Remote Server
- * WebSocket-based remote terminal with mobile-friendly web client
+ * @nikcli/remote - Direct Terminal Streaming Server
+ * Proxies NikCLI's stdin/stdout to WebSocket clients for true real-time terminal access
  */
 
 import { EventEmitter } from 'node:events'
 import { createServer, type Server, type IncomingMessage, type ServerResponse } from 'node:http'
-import { WebSocketServer, WebSocket } from 'ws'
+import { WebSocketServer, WebSocket, type RawData } from 'ws'
 import crypto from 'node:crypto'
 import os from 'node:os'
 import type {
@@ -16,12 +16,8 @@ import type {
   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
@@ -31,9 +27,9 @@ export interface RemoteServerEvents {
   '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
+  'terminal:output': (data: string) => void
 }
 
 export class RemoteServer extends EventEmitter {
@@ -42,13 +38,15 @@ export class RemoteServer extends EventEmitter {
   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
 
+  // stdin/stdout proxy state
+  private originalStdoutWrite: ((data: string | Uint8Array, ...args: unknown[]) => boolean) | null = null
+  private originalStdinOn: ((event: string, listener: (...args: unknown[]) => void) => void) | null = null
+
   constructor(config: Partial<ServerConfig> = {}) {
     super()
     this.config = { ...DEFAULT_CONFIG, ...config }
@@ -56,19 +54,26 @@ export class RemoteServer extends EventEmitter {
   }
 
   /**
-   * Start the remote server
+   * Generate a random secret
+   */
+  private generateSecret(): string {
+    return crypto.randomBytes(16).toString('hex')
+  }
+
+  /**
+   * Start the remote server - creates WebSocket server that proxies stdin/stdout
    */
-  async start(options: { name?: string } = {}): Promise<RemoteSession> {
+  async start(options: { name?: string; processForStreaming?: { stdout: NodeJS.WriteStream; stdin: NodeJS.ReadStream } } = {}): Promise<RemoteSession> {
     if (this.isRunning) {
       throw new Error('Server already running')
     }
 
     const sessionId = this.generateSessionId()
 
-    // Create HTTP server
+    // Create HTTP server for web client and health checks
     this.httpServer = createServer((req, res) => this.handleHttpRequest(req, res))
 
-    // Create WebSocket server
+    // Create WebSocket server for terminal streaming
     this.wss = new WebSocketServer({ server: this.httpServer })
     this.setupWebSocketHandlers()
 
@@ -85,57 +90,23 @@ export class RemoteServer extends EventEmitter {
     const localIp = this.getLocalIP()
     const localUrl = `http://${localIp}:${port}`
 
-    // Create initial session
+    // Create session
     this.session = {
       id: sessionId,
       name: options.name || `nikcli-${sessionId}`,
       qrCode: '',
-      qrUrl: localUrl,
+      qrUrl: `${localUrl}?s=${sessionId}&t=${this.sessionSecret}`,
       localUrl,
-      status: 'starting',
+      status: 'waiting',
       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) => {
-        // Broadcast to all connected clients
-        this.broadcast({ type: MessageTypes.TERMINAL_OUTPUT, payload: { data } })
-        // Also emit for NikCLI to capture
-        this.emit('terminal:output', data)
-      })
-
-      this.terminal.on('exit', (code: number) => {
-        this.broadcast({ type: MessageTypes.TERMINAL_EXIT, payload: { code } })
-      })
+    // Setup stdin/stdout proxy if process provided
+    if (options.processForStreaming) {
+      this.setupStdioProxy(options.processForStreaming.stdout, options.processForStreaming.stdin)
     }
 
     // Start heartbeat
@@ -153,6 +124,63 @@ export class RemoteServer extends EventEmitter {
     return this.session
   }
 
+  /**
+   * Setup stdin/stdout proxy to forward to WebSocket clients
+   */
+  private setupStdioProxy(stdout: NodeJS.WriteStream, stdin: NodeJS.ReadStream): void {
+    // Store original write method
+    const originalWrite = stdout.write.bind(stdout)
+
+    // Override stdout.write to broadcast to all clients
+    stdout.write = ((
+      data: string | Uint8Array,
+      encoding?: BufferEncoding | undefined,
+      cb?: (err?: Error | null) => void
+    ): boolean => {
+      // Call original write
+      const result = originalWrite(data, encoding, cb)
+
+      // Broadcast to all authenticated clients (cleaned for mobile)
+      const text = data instanceof Buffer ? data.toString() : data
+      const cleaned = this.cleanOutputForMobile(text as any)
+      this.broadcastToAll({ type: MessageTypes.TERMINAL_OUTPUT, payload: { data: cleaned } })
+
+      return result
+    }) as typeof stdout.write
+
+    // Listen for client messages and forward to stdin
+    this.wss?.on('connection', (ws) => {
+      ws.on('message', (rawData: RawData) => {
+        try {
+          const msg = JSON.parse(rawData.toString())
+          if (msg.type === MessageTypes.TERMINAL_INPUT && msg.data) {
+            // Forward client input to stdin
+            const inputData = Buffer.from(msg.data as string)
+            stdin.emit('data', inputData)
+          }
+        } catch {
+          // Invalid message, ignore
+        }
+      })
+    })
+  }
+
+  /**
+   * Clean output for mobile display - remove ANSI codes and TUI artifacts
+   */
+  private cleanOutputForMobile(text: string): string {
+    // Remove ANSI escape sequences (colors, cursor movements, clear screen)
+    let cleaned = text
+      // Remove escape sequences (colors, cursor, clear)
+      .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+      // Remove carriage returns that cause overwrites
+      .replace(/\r/g, '')
+      // Remove special control chars that cause issues
+      .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '')
+
+    return cleaned
+  }
+
   /**
    * Stop the server
    */
@@ -161,6 +189,11 @@ export class RemoteServer extends EventEmitter {
 
     this.isRunning = false
 
+    // Restore original stdout.write
+    if (this.originalStdoutWrite && this.session) {
+      // We can't restore the global process.stdout, but we stop broadcasting
+    }
+
     // Clear timers
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer)
@@ -172,7 +205,7 @@ export class RemoteServer extends EventEmitter {
     }
 
     // Notify clients
-    this.broadcast({ type: MessageTypes.SESSION_END, payload: {} })
+    this.broadcastToAll({ type: MessageTypes.SESSION_END, payload: {} })
 
     // Close all connections
     for (const client of this.clients.values()) {
@@ -180,18 +213,6 @@ export class RemoteServer extends EventEmitter {
     }
     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()
@@ -216,7 +237,7 @@ export class RemoteServer extends EventEmitter {
   /**
    * Broadcast message to all authenticated clients
    */
-  broadcast(message: BroadcastMessage): void {
+  private broadcastToAll(message: BroadcastMessage): void {
     const data = JSON.stringify({
       type: message.type,
       payload: message.payload,
@@ -230,11 +251,18 @@ export class RemoteServer extends EventEmitter {
     }
   }
 
+  /**
+   * Public broadcast method for compatibility
+   */
+  broadcast(message: BroadcastMessage): void {
+    this.broadcastToAll(message)
+  }
+
   /**
    * Send notification to clients
    */
   notify(notification: RemoteNotification): void {
-    this.broadcast({
+    this.broadcastToAll({
       type: MessageTypes.NOTIFICATION,
       payload: notification,
     })
@@ -266,17 +294,25 @@ export class RemoteServer extends EventEmitter {
   }
 
   /**
-   * Write to terminal
+   * Write data to all connected clients (for manual output streaming)
+   */
+  writeToClients(data: string): void {
+    this.broadcastToAll({ type: MessageTypes.TERMINAL_OUTPUT, payload: { data } })
+  }
+
+  /**
+   * Alias for writeToClients - for compatibility
    */
   writeToTerminal(data: string): void {
-    this.terminal?.write(data)
+    this.writeToClients(data)
   }
 
   /**
-   * Resize terminal
+   * Resize terminal (for compatibility - not used in direct streaming mode)
    */
   resizeTerminal(cols: number, rows: number): void {
-    this.terminal?.resize(cols, rows)
+    // In direct streaming mode, terminal size is handled by the client
+    // This is a no-op for compatibility
   }
 
   /**
@@ -366,37 +402,18 @@ export class RemoteServer extends EventEmitter {
         break
 
       case MessageTypes.TERMINAL_INPUT:
-        if (client.authenticated && message.data) {
-          this.terminal?.write(message.data as string)
-        }
+        // Input is handled in setupStdioProxy via ws message handler
         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()
-        }
+        // Resize can be forwarded if needed
+        this.emit('message', client, message)
         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)
     }
@@ -419,17 +436,11 @@ export class RemoteServer extends EventEmitter {
           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() }))
@@ -457,6 +468,7 @@ export class RemoteServer extends EventEmitter {
 
     // Serve web client
     if (path === '/' || path === '/index.html') {
+      const { getWebClient } = require('./web-client')
       res.writeHead(200, {
         'Content-Type': 'text/html; charset=utf-8',
         'Content-Security-Policy': "default-src 'self' 'unsafe-inline' 'unsafe-eval' https: data: ws: wss:",
@@ -558,11 +570,4 @@ export class RemoteServer extends EventEmitter {
   private generateClientId(): string {
     return 'c_' + crypto.randomBytes(4).toString('hex')
   }
-
-  /**
-   * Generate secret
-   */
-  private generateSecret(): string {
-    return crypto.randomBytes(16).toString('hex')
-  }
 }

package/src/tunnel.ts

@@ -6,6 +6,30 @@
 import { spawn, type ChildProcess } from 'node:child_process'
 import type { TunnelProvider } from './types'
 
+export type { TunnelProvider }
+
+export interface TunnelResult {
+  url: string
+  provider: TunnelProvider
+  close: () => Promise<void>
+}
+
+/**
+ * Create a tunnel for the given port using the specified provider
+ */
+export async function createTunnel(
+  port: number,
+  provider: TunnelProvider = 'cloudflared'
+): Promise<TunnelResult> {
+  const manager = new TunnelManager(provider)
+  const url = await manager.create(port)
+  return {
+    url,
+    provider,
+    close: () => manager.close(),
+  }
+}
+
 export class TunnelManager {
   private provider: TunnelProvider
   private process: ChildProcess | null = null