nikcli-remote 1.0.0

package/src/tunnel.ts

@@ -0,0 +1,258 @@
+/**
+ * @nikcli/remote - Tunnel Manager
+ * Provides public URL access via various tunnel providers
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process'
+import type { TunnelProvider } from './types'
+
+export class TunnelManager {
+  private provider: TunnelProvider
+  private process: ChildProcess | null = null
+  private url: string | null = null
+  private tunnelInstance: any = null
+
+  constructor(provider: TunnelProvider) {
+    this.provider = provider
+  }
+
+  /**
+   * Create tunnel and return public URL
+   */
+  async create(port: number): Promise<string> {
+    switch (this.provider) {
+      case 'localtunnel':
+        return this.createLocaltunnel(port)
+      case 'cloudflared':
+        return this.createCloudflared(port)
+      case 'ngrok':
+        return this.createNgrok(port)
+      default:
+        throw new Error(`Unknown tunnel provider: ${this.provider}`)
+    }
+  }
+
+  /**
+   * Close tunnel
+   */
+  async close(): Promise<void> {
+    if (this.tunnelInstance?.close) {
+      this.tunnelInstance.close()
+      this.tunnelInstance = null
+    }
+    if (this.process) {
+      this.process.kill()
+      this.process = null
+    }
+    this.url = null
+  }
+
+  /**
+   * Get tunnel URL
+   */
+  getUrl(): string | null {
+    return this.url
+  }
+
+  /**
+   * Create localtunnel
+   */
+  private async createLocaltunnel(port: number): Promise<string> {
+    // Try library first
+    try {
+      const localtunnel = await import('localtunnel')
+      const tunnel = await localtunnel.default({ port })
+      this.tunnelInstance = tunnel
+      this.url = tunnel.url
+
+      tunnel.on('close', () => {
+        this.url = null
+      })
+
+      return tunnel.url
+    } catch {
+      // Try CLI
+      return this.createLocaltunnelCli(port)
+    }
+  }
+
+  /**
+   * Create localtunnel via CLI
+   */
+  private createLocaltunnelCli(port: number): Promise<string> {
+    return new Promise((resolve, reject) => {
+      this.process = spawn('npx', ['localtunnel', '--port', port.toString()], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: true,
+      })
+
+      let output = ''
+      const timeout = setTimeout(() => {
+        reject(new Error('Localtunnel timeout'))
+      }, 30000)
+
+      this.process.stdout?.on('data', (data: Buffer) => {
+        output += data.toString()
+        const match = output.match(/your url is:\s*(https?:\/\/[^\s]+)/i)
+        if (match) {
+          clearTimeout(timeout)
+          this.url = match[1]
+          resolve(match[1])
+        }
+      })
+
+      this.process.stderr?.on('data', (data: Buffer) => {
+        output += data.toString()
+      })
+
+      this.process.on('error', (error) => {
+        clearTimeout(timeout)
+        reject(error)
+      })
+
+      this.process.on('exit', (code) => {
+        if (code !== 0 && !this.url) {
+          clearTimeout(timeout)
+          reject(new Error(`Localtunnel exited with code ${code}`))
+        }
+      })
+    })
+  }
+
+  /**
+   * Create cloudflared tunnel
+   */
+  private createCloudflared(port: number): Promise<string> {
+    return new Promise((resolve, reject) => {
+      this.process = spawn(
+        'cloudflared',
+        ['tunnel', '--url', `http://localhost:${port}`],
+        {
+          stdio: ['pipe', 'pipe', 'pipe'],
+        }
+      )
+
+      let output = ''
+      const timeout = setTimeout(() => {
+        reject(new Error('Cloudflared timeout'))
+      }, 30000)
+
+      const handleData = (data: Buffer) => {
+        output += data.toString()
+        // Cloudflared outputs URL to stderr
+        const match = output.match(/(https:\/\/[^\s]+\.trycloudflare\.com)/i)
+        if (match) {
+          clearTimeout(timeout)
+          this.url = match[1]
+          resolve(match[1])
+        }
+      }
+
+      this.process.stdout?.on('data', handleData)
+      this.process.stderr?.on('data', handleData)
+
+      this.process.on('error', (error) => {
+        clearTimeout(timeout)
+        reject(error)
+      })
+
+      this.process.on('exit', (code) => {
+        if (code !== 0 && !this.url) {
+          clearTimeout(timeout)
+          reject(new Error(`Cloudflared exited with code ${code}`))
+        }
+      })
+    })
+  }
+
+  /**
+   * Create ngrok tunnel
+   */
+  private createNgrok(port: number): Promise<string> {
+    return new Promise((resolve, reject) => {
+      this.process = spawn('ngrok', ['http', port.toString(), '--log=stdout'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      })
+
+      let output = ''
+      const timeout = setTimeout(() => {
+        reject(new Error('Ngrok timeout'))
+      }, 30000)
+
+      this.process.stdout?.on('data', (data: Buffer) => {
+        output += data.toString()
+        // Parse ngrok log output
+        const match = output.match(/url=(https?:\/\/[^\s]+)/i)
+        if (match) {
+          clearTimeout(timeout)
+          this.url = match[1]
+          resolve(match[1])
+        }
+      })
+
+      this.process.stderr?.on('data', (data: Buffer) => {
+        output += data.toString()
+      })
+
+      this.process.on('error', (error) => {
+        clearTimeout(timeout)
+        reject(error)
+      })
+
+      this.process.on('exit', (code) => {
+        if (code !== 0 && !this.url) {
+          clearTimeout(timeout)
+          reject(new Error(`Ngrok exited with code ${code}`))
+        }
+      })
+    })
+  }
+}
+
+/**
+ * Check if a tunnel provider is available
+ */
+export async function checkTunnelAvailability(provider: TunnelProvider): Promise<boolean> {
+  try {
+    const { execSync } = await import('node:child_process')
+
+    switch (provider) {
+      case 'localtunnel':
+        try {
+          await import('localtunnel')
+          return true
+        } catch {
+          execSync('npx localtunnel --version', { stdio: 'pipe' })
+          return true
+        }
+
+      case 'cloudflared':
+        execSync('cloudflared --version', { stdio: 'pipe' })
+        return true
+
+      case 'ngrok':
+        execSync('ngrok version', { stdio: 'pipe' })
+        return true
+
+      default:
+        return false
+    }
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Find best available tunnel provider
+ */
+export async function findAvailableTunnel(): Promise<TunnelProvider | null> {
+  const providers: TunnelProvider[] = ['localtunnel', 'cloudflared', 'ngrok']
+
+  for (const provider of providers) {
+    if (await checkTunnelAvailability(provider)) {
+      return provider
+    }
+  }
+
+  return null
+}

package/src/types.ts

@@ -0,0 +1,169 @@
+/**
+ * @nikcli/remote - Type definitions
+ */
+
+export type SessionStatus = 'starting' | 'waiting' | 'connected' | 'stopped' | 'error'
+export type TunnelProvider = 'localtunnel' | 'cloudflared' | 'ngrok' | 'none'
+
+export interface DeviceInfo {
+  id: string
+  userAgent?: string
+  connectedAt: Date
+  lastActivity: Date
+  ip?: string
+}
+
+export interface RemoteSession {
+  id: string
+  name: string
+  qrCode: string
+  qrUrl: string
+  localUrl: string
+  tunnelUrl?: string
+  status: SessionStatus
+  connectedDevices: DeviceInfo[]
+  startedAt: Date
+  lastActivity: Date
+  error?: string
+  port: number
+}
+
+export interface ServerConfig {
+  /** Port to listen on (0 = auto-assign) */
+  port: number
+  /** Host to bind to */
+  host: string
+  /** Enable tunnel for public access */
+  enableTunnel: boolean
+  /** Tunnel provider */
+  tunnelProvider: TunnelProvider
+  /** Session secret for authentication */
+  sessionSecret?: string
+  /** Maximum concurrent connections */
+  maxConnections: number
+  /** Heartbeat interval in ms */
+  heartbeatInterval: number
+  /** Shell command to spawn */
+  shell: string
+  /** Initial terminal columns */
+  cols: number
+  /** Initial terminal rows */
+  rows: number
+  /** Working directory for shell */
+  cwd?: string
+  /** Environment variables */
+  env?: Record<string, string>
+  /** Enable terminal (PTY) */
+  enableTerminal: boolean
+  /** Session timeout in ms (0 = no timeout) */
+  sessionTimeout: number
+}
+
+export interface BroadcastMessage {
+  type: string
+  payload: unknown
+  timestamp?: number
+}
+
+export interface RemoteNotification {
+  type: 'success' | 'error' | 'warning' | 'info'
+  title: string
+  body: string
+  data?: unknown
+}
+
+export interface ClientMessage {
+  type: string
+  [key: string]: unknown
+}
+
+export interface ServerMessage {
+  type: string
+  payload?: unknown
+  timestamp: number
+}
+
+export interface TerminalData {
+  data: string
+}
+
+export interface TerminalResize {
+  cols: number
+  rows: number
+}
+
+export interface CommandMessage {
+  command: string
+  args?: string[]
+}
+
+export interface ClientConnection {
+  id: string
+  authenticated: boolean
+  device: DeviceInfo
+  lastPing: number
+}
+
+export const DEFAULT_CONFIG: ServerConfig = {
+  port: 0,
+  host: '0.0.0.0',
+  enableTunnel: true,
+  tunnelProvider: 'localtunnel',
+  maxConnections: 5,
+  heartbeatInterval: 30000,
+  shell: '/bin/bash',
+  cols: 80,
+  rows: 24,
+  enableTerminal: true,
+  sessionTimeout: 0,
+}
+
+/**
+ * Get default shell based on platform
+ */
+export function getDefaultShell(): string {
+  if (typeof process !== 'undefined') {
+    if (process.platform === 'win32') return 'powershell.exe'
+    return process.env.SHELL || '/bin/bash'
+  }
+  return '/bin/bash'
+}
+
+// Message types for protocol
+export const MessageTypes = {
+  // Auth
+  AUTH_REQUIRED: 'auth:required',
+  AUTH: 'auth',
+  AUTH_SUCCESS: 'auth:success',
+  AUTH_FAILED: 'auth:failed',
+
+  // Terminal
+  TERMINAL_OUTPUT: 'terminal:output',
+  TERMINAL_INPUT: 'terminal:input',
+  TERMINAL_RESIZE: 'terminal:resize',
+  TERMINAL_EXIT: 'terminal:exit',
+  TERMINAL_CLEAR: 'terminal:clear',
+
+  // Notifications
+  NOTIFICATION: 'notification',
+
+  // Heartbeat
+  PING: 'ping',
+  PONG: 'pong',
+
+  // Session
+  SESSION_INFO: 'session:info',
+  SESSION_END: 'session:end',
+
+  // Commands (NikCLI specific)
+  COMMAND: 'command',
+  COMMAND_RESULT: 'command:result',
+
+  // Agent events
+  AGENT_START: 'agent:start',
+  AGENT_PROGRESS: 'agent:progress',
+  AGENT_COMPLETE: 'agent:complete',
+  AGENT_ERROR: 'agent:error',
+} as const
+
+export type MessageType = (typeof MessageTypes)[keyof typeof MessageTypes]