nikcli-remote 1.0.8 → 1.0.10

package/dist/index.js

@@ -2,15 +2,233 @@ import {
   DEFAULT_CONFIG,
   MessageTypes,
   RemoteServer,
-  TerminalManager,
-  getWebClient
-} from "./chunk-FYVPBMXV.js";
-import "./chunk-MCKGQKYU.js";
+  getWebClient,
+  init_web_client
+} from "./chunk-TIYMAVGV.js";
+import "./chunk-GI5RMYH6.js";
+
+// src/tunnel.ts
+import { spawn } from "child_process";
+async function createTunnel(port, provider = "cloudflared") {
+  const manager = new TunnelManager(provider);
+  const url = await manager.create(port);
+  return {
+    url,
+    provider,
+    close: () => manager.close()
+  };
+}
+var TunnelManager = class {
+  provider;
+  process = null;
+  url = null;
+  tunnelInstance = null;
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /**
+   * Create tunnel and return public URL
+   */
+  async create(port) {
+    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() {
+    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() {
+    return this.url;
+  }
+  /**
+   * Create localtunnel
+   */
+  async createLocaltunnel(port) {
+    try {
+      const localtunnel = await import("./localtunnel-6DCQIYU6.js");
+      const tunnel = await localtunnel.default({ port });
+      this.tunnelInstance = tunnel;
+      this.url = tunnel.url;
+      tunnel.on("close", () => {
+        this.url = null;
+      });
+      return tunnel.url;
+    } catch {
+      return this.createLocaltunnelCli(port);
+    }
+  }
+  /**
+   * Create localtunnel via CLI
+   */
+  createLocaltunnelCli(port) {
+    return new Promise((resolve, reject) => {
+      this.process = spawn("npx", ["localtunnel", "--port", port.toString(), "--print-requests", "false"], {
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true
+      });
+      let output = "";
+      const timeout = setTimeout(() => {
+        reject(new Error("Localtunnel timeout"));
+      }, 3e4);
+      this.process.stdout?.on("data", (data) => {
+        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", () => {
+      });
+      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
+   */
+  createCloudflared(port) {
+    return new Promise((resolve, reject) => {
+      this.process = spawn(
+        "cloudflared",
+        ["tunnel", "--url", `http://localhost:${port}`, "--metrics", "localhost:0"],
+        {
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+      let output = "";
+      const timeout = setTimeout(() => {
+        reject(new Error("Cloudflared timeout"));
+      }, 3e4);
+      const handleData = (data) => {
+        output += data.toString();
+        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
+   */
+  createNgrok(port) {
+    return new Promise((resolve, reject) => {
+      this.process = spawn("ngrok", ["http", port.toString(), "--log=stdout", "--log-level=info"], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let output = "";
+      const timeout = setTimeout(() => {
+        reject(new Error("Ngrok timeout"));
+      }, 3e4);
+      this.process.stdout?.on("data", (data) => {
+        output += data.toString();
+        const match = output.match(/url=(https?:\/\/[^\s]+)/i);
+        if (match) {
+          clearTimeout(timeout);
+          this.url = match[1];
+          resolve(match[1]);
+        }
+      });
+      this.process.stderr?.on("data", () => {
+      });
+      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}`));
+        }
+      });
+    });
+  }
+};
+async function checkTunnelAvailability(provider) {
+  try {
+    const { execSync } = await import("child_process");
+    switch (provider) {
+      case "localtunnel":
+        try {
+          await import("./localtunnel-6DCQIYU6.js");
+          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;
+  }
+}
+async function findAvailableTunnel() {
+  const providers = ["localtunnel", "cloudflared", "ngrok"];
+  for (const provider of providers) {
+    if (await checkTunnelAvailability(provider)) {
+      return provider;
+    }
+  }
+  return null;
+}
 
 // src/index.ts
+init_web_client();
 async function createRemoteServer(config = {}) {
-  const { RemoteServer: RemoteServer2 } = await import("./server-OYMSDTRP.js");
-  const server = new RemoteServer2(config);
+  const { RemoteServer: RemoteServerCls } = await import("./server-O3KTQ4KJ.js");
+  const server = new RemoteServerCls(config);
   const session = await server.start();
   return { server, session };
 }
@@ -18,7 +236,10 @@ export {
   DEFAULT_CONFIG,
   MessageTypes,
   RemoteServer,
-  TerminalManager,
+  TunnelManager,
+  checkTunnelAvailability,
   createRemoteServer,
+  createTunnel,
+  findAvailableTunnel,
   getWebClient
 };

package/dist/{localtunnel-XT32JGNN.js → localtunnel-6DCQIYU6.js}

@@ -1,7 +1,7 @@
 import {
   __commonJS,
   __require
-} from "./chunk-MCKGQKYU.js";
+} from "./chunk-GI5RMYH6.js";
 
 // node_modules/axios/lib/helpers/bind.js
 var require_bind = __commonJS({

package/dist/server-O3KTQ4KJ.js

@@ -0,0 +1,7 @@
+import {
+  RemoteServer
+} from "./chunk-TIYMAVGV.js";
+import "./chunk-GI5RMYH6.js";
+export {
+  RemoteServer
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nikcli-remote",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Native remote terminal server for NikCLI - Mobile control via WebSocket",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,25 +1,70 @@
 /**
- * @nikcli/remote
- * Native remote terminal server for NikCLI
+ * @nikcli/remote - Enterprise Terminal Streaming
  *
- * Provides WebSocket-based remote access to NikCLI from mobile devices.
+ * Direct stdin/stdout streaming for true real-time terminal access.
+ * No fake PTY - mobile sees your actual NikCLI terminal.
+ *
+ * @example
+ * ```typescript
+ * import { RemoteServer, createTunnel } from '@nikcli/remote'
+ *
+ * const server = new RemoteServer()
+ * const session = await server.start({
+ *   name: 'my-terminal',
+ *   processForStreaming: {
+ *     stdout: process.stdout,
+ *     stdin: process.stdin,
+ *   },
+ * })
+ *
+ * // Create public tunnel
+ * const tunnelUrl = await createTunnel(session.port, 'cloudflared')
+ * console.log('Access your terminal:', tunnelUrl)
+ * ```
  */
 
-export { RemoteServer, type RemoteServerEvents } from './server'
-export { TerminalManager, type TerminalConfig } from './terminal'
+// Core server
+export { RemoteServer } from './server'
+export type { RemoteServerEvents } from './server'
+
+// Tunnel management
+export {
+  TunnelManager,
+  createTunnel,
+  checkTunnelAvailability,
+  findAvailableTunnel,
+  type TunnelResult,
+} from './tunnel'
+
+// Web client
 export { getWebClient } from './web-client'
+
+// Types - re-export for convenience
 export type {
-  SessionStatus, TunnelProvider, DeviceInfo, RemoteSession,
-  ServerConfig, BroadcastMessage, RemoteNotification, ClientMessage,
-  ServerMessage, TerminalData, TerminalResize, CommandMessage,
+  DeviceInfo,
+  SessionStatus,
+  RemoteNotification,
+  ClientMessage,
+  BroadcastMessage,
+  ServerConfig,
+  RemoteSession,
+  TunnelProvider,
 } from './types'
+
+// Constants
 export { DEFAULT_CONFIG, MessageTypes } from './types'
 
+import type { RemoteServer } from './server'
+import type { ServerConfig, RemoteSession } from './types'
+
+/**
+ * Create a remote server with streaming in one call
+ */
 export async function createRemoteServer(
-  config: Partial<import('./types').ServerConfig> = {}
-) {
-  const { RemoteServer } = await import('./server')
-  const server = new RemoteServer(config)
+  config: Partial<ServerConfig> = {}
+): Promise<{ server: RemoteServer; session: RemoteSession }> {
+  const { RemoteServer: RemoteServerCls } = await import('./server')
+  const server = new RemoteServerCls(config)
   const session = await server.start()
   return { server, session }
 }