nikcli-remote 1.0.0

package/dist/chunk-TJTKYXIZ.js

@@ -0,0 +1,2782 @@
+import {
+  __commonJS,
+  __require
+} from "./chunk-MCKGQKYU.js";
+
+// node_modules/node-pty/lib/utils.js
+var require_utils = __commonJS({
+  "node_modules/node-pty/lib/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadNativeModule = exports.assign = void 0;
+    function assign(target) {
+      var sources = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+      }
+      sources.forEach(function(source) {
+        return Object.keys(source).forEach(function(key) {
+          return target[key] = source[key];
+        });
+      });
+      return target;
+    }
+    exports.assign = assign;
+    function loadNativeModule(name) {
+      var dirs = ["build/Release", "build/Debug", "prebuilds/" + process.platform + "-" + process.arch];
+      var relative = ["..", "."];
+      var lastError;
+      for (var _i = 0, dirs_1 = dirs; _i < dirs_1.length; _i++) {
+        var d = dirs_1[_i];
+        for (var _a = 0, relative_1 = relative; _a < relative_1.length; _a++) {
+          var r = relative_1[_a];
+          var dir = r + "/" + d + "/";
+          try {
+            return { dir, module: __require(dir + "/" + name + ".node") };
+          } catch (e) {
+            lastError = e;
+          }
+        }
+      }
+      throw new Error("Failed to load native module: " + name + ".node, checked: " + dirs.join(", ") + ": " + lastError);
+    }
+    exports.loadNativeModule = loadNativeModule;
+  }
+});
+
+// node_modules/node-pty/lib/eventEmitter2.js
+var require_eventEmitter2 = __commonJS({
+  "node_modules/node-pty/lib/eventEmitter2.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EventEmitter2 = void 0;
+    var EventEmitter22 = (
+      /** @class */
+      (function() {
+        function EventEmitter23() {
+          this._listeners = [];
+        }
+        Object.defineProperty(EventEmitter23.prototype, "event", {
+          get: function() {
+            var _this = this;
+            if (!this._event) {
+              this._event = function(listener) {
+                _this._listeners.push(listener);
+                var disposable = {
+                  dispose: function() {
+                    for (var i = 0; i < _this._listeners.length; i++) {
+                      if (_this._listeners[i] === listener) {
+                        _this._listeners.splice(i, 1);
+                        return;
+                      }
+                    }
+                  }
+                };
+                return disposable;
+              };
+            }
+            return this._event;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        EventEmitter23.prototype.fire = function(data) {
+          var queue = [];
+          for (var i = 0; i < this._listeners.length; i++) {
+            queue.push(this._listeners[i]);
+          }
+          for (var i = 0; i < queue.length; i++) {
+            queue[i].call(void 0, data);
+          }
+        };
+        return EventEmitter23;
+      })()
+    );
+    exports.EventEmitter2 = EventEmitter22;
+  }
+});
+
+// node_modules/node-pty/lib/terminal.js
+var require_terminal = __commonJS({
+  "node_modules/node-pty/lib/terminal.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Terminal = exports.DEFAULT_ROWS = exports.DEFAULT_COLS = void 0;
+    var events_1 = __require("events");
+    var eventEmitter2_1 = require_eventEmitter2();
+    exports.DEFAULT_COLS = 80;
+    exports.DEFAULT_ROWS = 24;
+    var FLOW_CONTROL_PAUSE = "";
+    var FLOW_CONTROL_RESUME = "";
+    var Terminal = (
+      /** @class */
+      (function() {
+        function Terminal2(opt) {
+          this._pid = 0;
+          this._fd = 0;
+          this._cols = 0;
+          this._rows = 0;
+          this._readable = false;
+          this._writable = false;
+          this._onData = new eventEmitter2_1.EventEmitter2();
+          this._onExit = new eventEmitter2_1.EventEmitter2();
+          this._internalee = new events_1.EventEmitter();
+          this.handleFlowControl = !!(opt === null || opt === void 0 ? void 0 : opt.handleFlowControl);
+          this._flowControlPause = (opt === null || opt === void 0 ? void 0 : opt.flowControlPause) || FLOW_CONTROL_PAUSE;
+          this._flowControlResume = (opt === null || opt === void 0 ? void 0 : opt.flowControlResume) || FLOW_CONTROL_RESUME;
+          if (!opt) {
+            return;
+          }
+          this._checkType("name", opt.name ? opt.name : void 0, "string");
+          this._checkType("cols", opt.cols ? opt.cols : void 0, "number");
+          this._checkType("rows", opt.rows ? opt.rows : void 0, "number");
+          this._checkType("cwd", opt.cwd ? opt.cwd : void 0, "string");
+          this._checkType("env", opt.env ? opt.env : void 0, "object");
+          this._checkType("uid", opt.uid ? opt.uid : void 0, "number");
+          this._checkType("gid", opt.gid ? opt.gid : void 0, "number");
+          this._checkType("encoding", opt.encoding ? opt.encoding : void 0, "string");
+        }
+        Object.defineProperty(Terminal2.prototype, "onData", {
+          get: function() {
+            return this._onData.event;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(Terminal2.prototype, "onExit", {
+          get: function() {
+            return this._onExit.event;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(Terminal2.prototype, "pid", {
+          get: function() {
+            return this._pid;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(Terminal2.prototype, "cols", {
+          get: function() {
+            return this._cols;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(Terminal2.prototype, "rows", {
+          get: function() {
+            return this._rows;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Terminal2.prototype.write = function(data) {
+          if (this.handleFlowControl) {
+            if (data === this._flowControlPause) {
+              this.pause();
+              return;
+            }
+            if (data === this._flowControlResume) {
+              this.resume();
+              return;
+            }
+          }
+          this._write(data);
+        };
+        Terminal2.prototype._forwardEvents = function() {
+          var _this = this;
+          this.on("data", function(e) {
+            return _this._onData.fire(e);
+          });
+          this.on("exit", function(exitCode, signal) {
+            return _this._onExit.fire({ exitCode, signal });
+          });
+        };
+        Terminal2.prototype._checkType = function(name, value, type, allowArray) {
+          if (allowArray === void 0) {
+            allowArray = false;
+          }
+          if (value === void 0) {
+            return;
+          }
+          if (allowArray) {
+            if (Array.isArray(value)) {
+              value.forEach(function(v, i) {
+                if (typeof v !== type) {
+                  throw new Error(name + "[" + i + "] must be a " + type + " (not a " + typeof v[i] + ")");
+                }
+              });
+              return;
+            }
+          }
+          if (typeof value !== type) {
+            throw new Error(name + " must be a " + type + " (not a " + typeof value + ")");
+          }
+        };
+        Terminal2.prototype.end = function(data) {
+          this._socket.end(data);
+        };
+        Terminal2.prototype.pipe = function(dest, options) {
+          return this._socket.pipe(dest, options);
+        };
+        Terminal2.prototype.pause = function() {
+          return this._socket.pause();
+        };
+        Terminal2.prototype.resume = function() {
+          return this._socket.resume();
+        };
+        Terminal2.prototype.setEncoding = function(encoding) {
+          if (this._socket._decoder) {
+            delete this._socket._decoder;
+          }
+          if (encoding) {
+            this._socket.setEncoding(encoding);
+          }
+        };
+        Terminal2.prototype.addListener = function(eventName, listener) {
+          this.on(eventName, listener);
+        };
+        Terminal2.prototype.on = function(eventName, listener) {
+          if (eventName === "close") {
+            this._internalee.on("close", listener);
+            return;
+          }
+          this._socket.on(eventName, listener);
+        };
+        Terminal2.prototype.emit = function(eventName) {
+          var args = [];
+          for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+          }
+          if (eventName === "close") {
+            return this._internalee.emit.apply(this._internalee, arguments);
+          }
+          return this._socket.emit.apply(this._socket, arguments);
+        };
+        Terminal2.prototype.listeners = function(eventName) {
+          return this._socket.listeners(eventName);
+        };
+        Terminal2.prototype.removeListener = function(eventName, listener) {
+          this._socket.removeListener(eventName, listener);
+        };
+        Terminal2.prototype.removeAllListeners = function(eventName) {
+          this._socket.removeAllListeners(eventName);
+        };
+        Terminal2.prototype.once = function(eventName, listener) {
+          this._socket.once(eventName, listener);
+        };
+        Terminal2.prototype._close = function() {
+          this._socket.readable = false;
+          this.write = function() {
+          };
+          this.end = function() {
+          };
+          this._writable = false;
+          this._readable = false;
+        };
+        Terminal2.prototype._parseEnv = function(env) {
+          var keys = Object.keys(env || {});
+          var pairs = [];
+          for (var i = 0; i < keys.length; i++) {
+            if (keys[i] === void 0) {
+              continue;
+            }
+            pairs.push(keys[i] + "=" + env[keys[i]]);
+          }
+          return pairs;
+        };
+        return Terminal2;
+      })()
+    );
+    exports.Terminal = Terminal;
+  }
+});
+
+// node_modules/node-pty/lib/shared/conout.js
+var require_conout = __commonJS({
+  "node_modules/node-pty/lib/shared/conout.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getWorkerPipeName = void 0;
+    function getWorkerPipeName(conoutPipeName) {
+      return conoutPipeName + "-worker";
+    }
+    exports.getWorkerPipeName = getWorkerPipeName;
+  }
+});
+
+// node_modules/node-pty/lib/windowsConoutConnection.js
+var require_windowsConoutConnection = __commonJS({
+  "node_modules/node-pty/lib/windowsConoutConnection.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ConoutConnection = void 0;
+    var worker_threads_1 = __require("worker_threads");
+    var conout_1 = require_conout();
+    var path_1 = __require("path");
+    var eventEmitter2_1 = require_eventEmitter2();
+    var FLUSH_DATA_INTERVAL = 1e3;
+    var ConoutConnection = (
+      /** @class */
+      (function() {
+        function ConoutConnection2(_conoutPipeName, _useConptyDll) {
+          var _this = this;
+          this._conoutPipeName = _conoutPipeName;
+          this._useConptyDll = _useConptyDll;
+          this._isDisposed = false;
+          this._onReady = new eventEmitter2_1.EventEmitter2();
+          var workerData = {
+            conoutPipeName: _conoutPipeName
+          };
+          var scriptPath = __dirname.replace("node_modules.asar", "node_modules.asar.unpacked");
+          this._worker = new worker_threads_1.Worker(path_1.join(scriptPath, "worker/conoutSocketWorker.js"), { workerData });
+          this._worker.on("message", function(message) {
+            switch (message) {
+              case 1:
+                _this._onReady.fire();
+                return;
+              default:
+                console.warn("Unexpected ConoutWorkerMessage", message);
+            }
+          });
+        }
+        Object.defineProperty(ConoutConnection2.prototype, "onReady", {
+          get: function() {
+            return this._onReady.event;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        ConoutConnection2.prototype.dispose = function() {
+          if (!this._useConptyDll && this._isDisposed) {
+            return;
+          }
+          this._isDisposed = true;
+          this._drainDataAndClose();
+        };
+        ConoutConnection2.prototype.connectSocket = function(socket) {
+          socket.connect(conout_1.getWorkerPipeName(this._conoutPipeName));
+        };
+        ConoutConnection2.prototype._drainDataAndClose = function() {
+          var _this = this;
+          if (this._drainTimeout) {
+            clearTimeout(this._drainTimeout);
+          }
+          this._drainTimeout = setTimeout(function() {
+            return _this._destroySocket();
+          }, FLUSH_DATA_INTERVAL);
+        };
+        ConoutConnection2.prototype._destroySocket = function() {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  return [4, this._worker.terminate()];
+                case 1:
+                  _a.sent();
+                  return [
+                    2
+                    /*return*/
+                  ];
+              }
+            });
+          });
+        };
+        return ConoutConnection2;
+      })()
+    );
+    exports.ConoutConnection = ConoutConnection;
+  }
+});
+
+// node_modules/node-pty/lib/windowsPtyAgent.js
+var require_windowsPtyAgent = __commonJS({
+  "node_modules/node-pty/lib/windowsPtyAgent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.argsToCommandLine = exports.WindowsPtyAgent = void 0;
+    var fs = __require("fs");
+    var os2 = __require("os");
+    var path = __require("path");
+    var child_process_1 = __require("child_process");
+    var net_1 = __require("net");
+    var windowsConoutConnection_1 = require_windowsConoutConnection();
+    var utils_1 = require_utils();
+    var conptyNative;
+    var winptyNative;
+    var FLUSH_DATA_INTERVAL = 1e3;
+    var WindowsPtyAgent = (
+      /** @class */
+      (function() {
+        function WindowsPtyAgent2(file, args, env, cwd, cols, rows, debug, _useConpty, _useConptyDll, conptyInheritCursor) {
+          var _this = this;
+          if (_useConptyDll === void 0) {
+            _useConptyDll = false;
+          }
+          if (conptyInheritCursor === void 0) {
+            conptyInheritCursor = false;
+          }
+          this._useConpty = _useConpty;
+          this._useConptyDll = _useConptyDll;
+          this._pid = 0;
+          this._innerPid = 0;
+          if (this._useConpty === void 0 || this._useConpty === true) {
+            this._useConpty = this._getWindowsBuildNumber() >= 18309;
+          }
+          if (this._useConpty) {
+            if (!conptyNative) {
+              conptyNative = utils_1.loadNativeModule("conpty").module;
+            }
+          } else {
+            if (!winptyNative) {
+              winptyNative = utils_1.loadNativeModule("pty").module;
+            }
+          }
+          this._ptyNative = this._useConpty ? conptyNative : winptyNative;
+          cwd = path.resolve(cwd);
+          var commandLine = argsToCommandLine(file, args);
+          var term;
+          if (this._useConpty) {
+            term = this._ptyNative.startProcess(file, cols, rows, debug, this._generatePipeName(), conptyInheritCursor, this._useConptyDll);
+          } else {
+            term = this._ptyNative.startProcess(file, commandLine, env, cwd, cols, rows, debug);
+            this._pid = term.pid;
+            this._innerPid = term.innerPid;
+          }
+          this._fd = term.fd;
+          this._pty = term.pty;
+          this._outSocket = new net_1.Socket();
+          this._outSocket.setEncoding("utf8");
+          this._conoutSocketWorker = new windowsConoutConnection_1.ConoutConnection(term.conout, this._useConptyDll);
+          this._conoutSocketWorker.onReady(function() {
+            _this._conoutSocketWorker.connectSocket(_this._outSocket);
+          });
+          this._outSocket.on("connect", function() {
+            _this._outSocket.emit("ready_datapipe");
+          });
+          var inSocketFD = fs.openSync(term.conin, "w");
+          this._inSocket = new net_1.Socket({
+            fd: inSocketFD,
+            readable: false,
+            writable: true
+          });
+          this._inSocket.setEncoding("utf8");
+          if (this._useConpty) {
+            var connect = this._ptyNative.connect(this._pty, commandLine, cwd, env, this._useConptyDll, function(c) {
+              return _this._$onProcessExit(c);
+            });
+            this._innerPid = connect.pid;
+          }
+        }
+        Object.defineProperty(WindowsPtyAgent2.prototype, "inSocket", {
+          get: function() {
+            return this._inSocket;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsPtyAgent2.prototype, "outSocket", {
+          get: function() {
+            return this._outSocket;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsPtyAgent2.prototype, "fd", {
+          get: function() {
+            return this._fd;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsPtyAgent2.prototype, "innerPid", {
+          get: function() {
+            return this._innerPid;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsPtyAgent2.prototype, "pty", {
+          get: function() {
+            return this._pty;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        WindowsPtyAgent2.prototype.resize = function(cols, rows) {
+          if (this._useConpty) {
+            if (this._exitCode !== void 0) {
+              throw new Error("Cannot resize a pty that has already exited");
+            }
+            this._ptyNative.resize(this._pty, cols, rows, this._useConptyDll);
+            return;
+          }
+          this._ptyNative.resize(this._pid, cols, rows);
+        };
+        WindowsPtyAgent2.prototype.clear = function() {
+          if (this._useConpty) {
+            this._ptyNative.clear(this._pty, this._useConptyDll);
+          }
+        };
+        WindowsPtyAgent2.prototype.kill = function() {
+          var _this = this;
+          if (this._useConpty) {
+            if (!this._useConptyDll) {
+              this._inSocket.readable = false;
+              this._outSocket.readable = false;
+              this._getConsoleProcessList().then(function(consoleProcessList) {
+                consoleProcessList.forEach(function(pid) {
+                  try {
+                    process.kill(pid);
+                  } catch (e) {
+                  }
+                });
+              });
+              this._ptyNative.kill(this._pty, this._useConptyDll);
+              this._conoutSocketWorker.dispose();
+            } else {
+              this._inSocket.destroy();
+              this._ptyNative.kill(this._pty, this._useConptyDll);
+              this._outSocket.on("data", function() {
+                _this._conoutSocketWorker.dispose();
+              });
+            }
+          } else {
+            var processList = this._ptyNative.getProcessList(this._pid);
+            this._ptyNative.kill(this._pid, this._innerPid);
+            processList.forEach(function(pid) {
+              try {
+                process.kill(pid);
+              } catch (e) {
+              }
+            });
+          }
+        };
+        WindowsPtyAgent2.prototype._getConsoleProcessList = function() {
+          var _this = this;
+          return new Promise(function(resolve) {
+            var agent = child_process_1.fork(path.join(__dirname, "conpty_console_list_agent"), [_this._innerPid.toString()]);
+            agent.on("message", function(message) {
+              clearTimeout(timeout);
+              resolve(message.consoleProcessList);
+            });
+            var timeout = setTimeout(function() {
+              agent.kill();
+              resolve([_this._innerPid]);
+            }, 5e3);
+          });
+        };
+        Object.defineProperty(WindowsPtyAgent2.prototype, "exitCode", {
+          get: function() {
+            if (this._useConpty) {
+              return this._exitCode;
+            }
+            var winptyExitCode = this._ptyNative.getExitCode(this._innerPid);
+            return winptyExitCode === -1 ? void 0 : winptyExitCode;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        WindowsPtyAgent2.prototype._getWindowsBuildNumber = function() {
+          var osVersion = /(\d+)\.(\d+)\.(\d+)/g.exec(os2.release());
+          var buildNumber = 0;
+          if (osVersion && osVersion.length === 4) {
+            buildNumber = parseInt(osVersion[3]);
+          }
+          return buildNumber;
+        };
+        WindowsPtyAgent2.prototype._generatePipeName = function() {
+          return "conpty-" + Math.random() * 1e7;
+        };
+        WindowsPtyAgent2.prototype._$onProcessExit = function(exitCode) {
+          var _this = this;
+          this._exitCode = exitCode;
+          if (!this._useConptyDll) {
+            this._flushDataAndCleanUp();
+            this._outSocket.on("data", function() {
+              return _this._flushDataAndCleanUp();
+            });
+          }
+        };
+        WindowsPtyAgent2.prototype._flushDataAndCleanUp = function() {
+          var _this = this;
+          if (this._useConptyDll) {
+            return;
+          }
+          if (this._closeTimeout) {
+            clearTimeout(this._closeTimeout);
+          }
+          this._closeTimeout = setTimeout(function() {
+            return _this._cleanUpProcess();
+          }, FLUSH_DATA_INTERVAL);
+        };
+        WindowsPtyAgent2.prototype._cleanUpProcess = function() {
+          if (this._useConptyDll) {
+            return;
+          }
+          this._inSocket.readable = false;
+          this._outSocket.readable = false;
+          this._outSocket.destroy();
+        };
+        return WindowsPtyAgent2;
+      })()
+    );
+    exports.WindowsPtyAgent = WindowsPtyAgent;
+    function argsToCommandLine(file, args) {
+      if (isCommandLine(args)) {
+        if (args.length === 0) {
+          return file;
+        }
+        return argsToCommandLine(file, []) + " " + args;
+      }
+      var argv = [file];
+      Array.prototype.push.apply(argv, args);
+      var result = "";
+      for (var argIndex = 0; argIndex < argv.length; argIndex++) {
+        if (argIndex > 0) {
+          result += " ";
+        }
+        var arg = argv[argIndex];
+        var hasLopsidedEnclosingQuote = xOr(arg[0] !== '"', arg[arg.length - 1] !== '"');
+        var hasNoEnclosingQuotes = arg[0] !== '"' && arg[arg.length - 1] !== '"';
+        var quote = arg === "" || (arg.indexOf(" ") !== -1 || arg.indexOf("	") !== -1) && (arg.length > 1 && (hasLopsidedEnclosingQuote || hasNoEnclosingQuotes));
+        if (quote) {
+          result += '"';
+        }
+        var bsCount = 0;
+        for (var i = 0; i < arg.length; i++) {
+          var p = arg[i];
+          if (p === "\\") {
+            bsCount++;
+          } else if (p === '"') {
+            result += repeatText("\\", bsCount * 2 + 1);
+            result += '"';
+            bsCount = 0;
+          } else {
+            result += repeatText("\\", bsCount);
+            bsCount = 0;
+            result += p;
+          }
+        }
+        if (quote) {
+          result += repeatText("\\", bsCount * 2);
+          result += '"';
+        } else {
+          result += repeatText("\\", bsCount);
+        }
+      }
+      return result;
+    }
+    exports.argsToCommandLine = argsToCommandLine;
+    function isCommandLine(args) {
+      return typeof args === "string";
+    }
+    function repeatText(text, count) {
+      var result = "";
+      for (var i = 0; i < count; i++) {
+        result += text;
+      }
+      return result;
+    }
+    function xOr(arg1, arg2) {
+      return arg1 && !arg2 || !arg1 && arg2;
+    }
+  }
+});
+
+// node_modules/node-pty/lib/windowsTerminal.js
+var require_windowsTerminal = __commonJS({
+  "node_modules/node-pty/lib/windowsTerminal.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.WindowsTerminal = void 0;
+    var terminal_1 = require_terminal();
+    var windowsPtyAgent_1 = require_windowsPtyAgent();
+    var utils_1 = require_utils();
+    var DEFAULT_FILE = "cmd.exe";
+    var DEFAULT_NAME = "Windows Shell";
+    var WindowsTerminal = (
+      /** @class */
+      (function(_super) {
+        __extends(WindowsTerminal2, _super);
+        function WindowsTerminal2(file, args, opt) {
+          var _this = _super.call(this, opt) || this;
+          _this._checkType("args", args, "string", true);
+          args = args || [];
+          file = file || DEFAULT_FILE;
+          opt = opt || {};
+          opt.env = opt.env || process.env;
+          if (opt.encoding) {
+            console.warn("Setting encoding on Windows is not supported");
+          }
+          var env = utils_1.assign({}, opt.env);
+          _this._cols = opt.cols || terminal_1.DEFAULT_COLS;
+          _this._rows = opt.rows || terminal_1.DEFAULT_ROWS;
+          var cwd = opt.cwd || process.cwd();
+          var name = opt.name || env.TERM || DEFAULT_NAME;
+          var parsedEnv = _this._parseEnv(env);
+          _this._isReady = false;
+          _this._deferreds = [];
+          _this._agent = new windowsPtyAgent_1.WindowsPtyAgent(file, args, parsedEnv, cwd, _this._cols, _this._rows, false, opt.useConpty, opt.useConptyDll, opt.conptyInheritCursor);
+          _this._socket = _this._agent.outSocket;
+          _this._pid = _this._agent.innerPid;
+          _this._fd = _this._agent.fd;
+          _this._pty = _this._agent.pty;
+          _this._socket.on("ready_datapipe", function() {
+            _this._socket.once("data", function() {
+              if (!_this._isReady) {
+                _this._isReady = true;
+                _this._deferreds.forEach(function(fn) {
+                  fn.run();
+                });
+                _this._deferreds = [];
+              }
+            });
+            _this._socket.on("error", function(err) {
+              _this._close();
+              if (err.code) {
+                if (~err.code.indexOf("errno 5") || ~err.code.indexOf("EIO"))
+                  return;
+              }
+              if (_this.listeners("error").length < 2) {
+                throw err;
+              }
+            });
+            _this._socket.on("close", function() {
+              _this.emit("exit", _this._agent.exitCode);
+              _this._close();
+            });
+          });
+          _this._file = file;
+          _this._name = name;
+          _this._readable = true;
+          _this._writable = true;
+          _this._forwardEvents();
+          return _this;
+        }
+        WindowsTerminal2.prototype._write = function(data) {
+          this._defer(this._doWrite, data);
+        };
+        WindowsTerminal2.prototype._doWrite = function(data) {
+          this._agent.inSocket.write(data);
+        };
+        WindowsTerminal2.open = function(options) {
+          throw new Error("open() not supported on windows, use Fork() instead.");
+        };
+        WindowsTerminal2.prototype.resize = function(cols, rows) {
+          var _this = this;
+          if (cols <= 0 || rows <= 0 || isNaN(cols) || isNaN(rows) || cols === Infinity || rows === Infinity) {
+            throw new Error("resizing must be done using positive cols and rows");
+          }
+          this._deferNoArgs(function() {
+            _this._agent.resize(cols, rows);
+            _this._cols = cols;
+            _this._rows = rows;
+          });
+        };
+        WindowsTerminal2.prototype.clear = function() {
+          var _this = this;
+          this._deferNoArgs(function() {
+            _this._agent.clear();
+          });
+        };
+        WindowsTerminal2.prototype.destroy = function() {
+          var _this = this;
+          this._deferNoArgs(function() {
+            _this.kill();
+          });
+        };
+        WindowsTerminal2.prototype.kill = function(signal) {
+          var _this = this;
+          this._deferNoArgs(function() {
+            if (signal) {
+              throw new Error("Signals not supported on windows.");
+            }
+            _this._close();
+            _this._agent.kill();
+          });
+        };
+        WindowsTerminal2.prototype._deferNoArgs = function(deferredFn) {
+          var _this = this;
+          if (this._isReady) {
+            deferredFn.call(this);
+            return;
+          }
+          this._deferreds.push({
+            run: function() {
+              return deferredFn.call(_this);
+            }
+          });
+        };
+        WindowsTerminal2.prototype._defer = function(deferredFn, arg) {
+          var _this = this;
+          if (this._isReady) {
+            deferredFn.call(this, arg);
+            return;
+          }
+          this._deferreds.push({
+            run: function() {
+              return deferredFn.call(_this, arg);
+            }
+          });
+        };
+        Object.defineProperty(WindowsTerminal2.prototype, "process", {
+          get: function() {
+            return this._name;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsTerminal2.prototype, "master", {
+          get: function() {
+            throw new Error("master is not supported on Windows");
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsTerminal2.prototype, "slave", {
+          get: function() {
+            throw new Error("slave is not supported on Windows");
+          },
+          enumerable: false,
+          configurable: true
+        });
+        return WindowsTerminal2;
+      })(terminal_1.Terminal)
+    );
+    exports.WindowsTerminal = WindowsTerminal;
+  }
+});
+
+// node_modules/node-pty/lib/unixTerminal.js
+var require_unixTerminal = __commonJS({
+  "node_modules/node-pty/lib/unixTerminal.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.UnixTerminal = void 0;
+    var fs = __require("fs");
+    var path = __require("path");
+    var tty = __require("tty");
+    var terminal_1 = require_terminal();
+    var utils_1 = require_utils();
+    var native = utils_1.loadNativeModule("pty");
+    var pty2 = native.module;
+    var helperPath = native.dir + "/spawn-helper";
+    helperPath = path.resolve(__dirname, helperPath);
+    helperPath = helperPath.replace("app.asar", "app.asar.unpacked");
+    helperPath = helperPath.replace("node_modules.asar", "node_modules.asar.unpacked");
+    var DEFAULT_FILE = "sh";
+    var DEFAULT_NAME = "xterm";
+    var DESTROY_SOCKET_TIMEOUT_MS = 200;
+    var UnixTerminal = (
+      /** @class */
+      (function(_super) {
+        __extends(UnixTerminal2, _super);
+        function UnixTerminal2(file, args, opt) {
+          var _a, _b;
+          var _this = _super.call(this, opt) || this;
+          _this._boundClose = false;
+          _this._emittedClose = false;
+          if (typeof args === "string") {
+            throw new Error("args as a string is not supported on unix.");
+          }
+          args = args || [];
+          file = file || DEFAULT_FILE;
+          opt = opt || {};
+          opt.env = opt.env || process.env;
+          _this._cols = opt.cols || terminal_1.DEFAULT_COLS;
+          _this._rows = opt.rows || terminal_1.DEFAULT_ROWS;
+          var uid = (_a = opt.uid) !== null && _a !== void 0 ? _a : -1;
+          var gid = (_b = opt.gid) !== null && _b !== void 0 ? _b : -1;
+          var env = utils_1.assign({}, opt.env);
+          if (opt.env === process.env) {
+            _this._sanitizeEnv(env);
+          }
+          var cwd = opt.cwd || process.cwd();
+          env.PWD = cwd;
+          var name = opt.name || env.TERM || DEFAULT_NAME;
+          env.TERM = name;
+          var parsedEnv = _this._parseEnv(env);
+          var encoding = opt.encoding === void 0 ? "utf8" : opt.encoding;
+          var onexit = function(code, signal) {
+            if (!_this._emittedClose) {
+              if (_this._boundClose) {
+                return;
+              }
+              _this._boundClose = true;
+              var timeout_1 = setTimeout(function() {
+                timeout_1 = null;
+                _this._socket.destroy();
+              }, DESTROY_SOCKET_TIMEOUT_MS);
+              _this.once("close", function() {
+                if (timeout_1 !== null) {
+                  clearTimeout(timeout_1);
+                }
+                _this.emit("exit", code, signal);
+              });
+              return;
+            }
+            _this.emit("exit", code, signal);
+          };
+          var term = pty2.fork(file, args, parsedEnv, cwd, _this._cols, _this._rows, uid, gid, encoding === "utf8", helperPath, onexit);
+          _this._socket = new tty.ReadStream(term.fd);
+          if (encoding !== null) {
+            _this._socket.setEncoding(encoding);
+          }
+          _this._writeStream = new CustomWriteStream(term.fd, encoding || void 0);
+          _this._socket.on("error", function(err) {
+            if (err.code) {
+              if (~err.code.indexOf("EAGAIN")) {
+                return;
+              }
+            }
+            _this._close();
+            if (!_this._emittedClose) {
+              _this._emittedClose = true;
+              _this.emit("close");
+            }
+            if (err.code) {
+              if (~err.code.indexOf("errno 5") || ~err.code.indexOf("EIO")) {
+                return;
+              }
+            }
+            if (_this.listeners("error").length < 2) {
+              throw err;
+            }
+          });
+          _this._pid = term.pid;
+          _this._fd = term.fd;
+          _this._pty = term.pty;
+          _this._file = file;
+          _this._name = name;
+          _this._readable = true;
+          _this._writable = true;
+          _this._socket.on("close", function() {
+            if (_this._emittedClose) {
+              return;
+            }
+            _this._emittedClose = true;
+            _this._close();
+            _this.emit("close");
+          });
+          _this._forwardEvents();
+          return _this;
+        }
+        Object.defineProperty(UnixTerminal2.prototype, "master", {
+          get: function() {
+            return this._master;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(UnixTerminal2.prototype, "slave", {
+          get: function() {
+            return this._slave;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        UnixTerminal2.prototype._write = function(data) {
+          this._writeStream.write(data);
+        };
+        Object.defineProperty(UnixTerminal2.prototype, "fd", {
+          /* Accessors */
+          get: function() {
+            return this._fd;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(UnixTerminal2.prototype, "ptsName", {
+          get: function() {
+            return this._pty;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        UnixTerminal2.open = function(opt) {
+          var self = Object.create(UnixTerminal2.prototype);
+          opt = opt || {};
+          if (arguments.length > 1) {
+            opt = {
+              cols: arguments[1],
+              rows: arguments[2]
+            };
+          }
+          var cols = opt.cols || terminal_1.DEFAULT_COLS;
+          var rows = opt.rows || terminal_1.DEFAULT_ROWS;
+          var encoding = opt.encoding === void 0 ? "utf8" : opt.encoding;
+          var term = pty2.open(cols, rows);
+          self._master = new tty.ReadStream(term.master);
+          if (encoding !== null) {
+            self._master.setEncoding(encoding);
+          }
+          self._master.resume();
+          self._slave = new tty.ReadStream(term.slave);
+          if (encoding !== null) {
+            self._slave.setEncoding(encoding);
+          }
+          self._slave.resume();
+          self._socket = self._master;
+          self._pid = -1;
+          self._fd = term.master;
+          self._pty = term.pty;
+          self._file = process.argv[0] || "node";
+          self._name = process.env.TERM || "";
+          self._readable = true;
+          self._writable = true;
+          self._socket.on("error", function(err) {
+            self._close();
+            if (self.listeners("error").length < 2) {
+              throw err;
+            }
+          });
+          self._socket.on("close", function() {
+            self._close();
+          });
+          return self;
+        };
+        UnixTerminal2.prototype.destroy = function() {
+          var _this = this;
+          this._close();
+          this._socket.once("close", function() {
+            _this.kill("SIGHUP");
+          });
+          this._socket.destroy();
+          this._writeStream.dispose();
+        };
+        UnixTerminal2.prototype.kill = function(signal) {
+          try {
+            process.kill(this.pid, signal || "SIGHUP");
+          } catch (e) {
+          }
+        };
+        Object.defineProperty(UnixTerminal2.prototype, "process", {
+          /**
+           * Gets the name of the process.
+           */
+          get: function() {
+            if (process.platform === "darwin") {
+              var title = pty2.process(this._fd);
+              return title !== "kernel_task" ? title : this._file;
+            }
+            return pty2.process(this._fd, this._pty) || this._file;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        UnixTerminal2.prototype.resize = function(cols, rows) {
+          if (cols <= 0 || rows <= 0 || isNaN(cols) || isNaN(rows) || cols === Infinity || rows === Infinity) {
+            throw new Error("resizing must be done using positive cols and rows");
+          }
+          pty2.resize(this._fd, cols, rows);
+          this._cols = cols;
+          this._rows = rows;
+        };
+        UnixTerminal2.prototype.clear = function() {
+        };
+        UnixTerminal2.prototype._sanitizeEnv = function(env) {
+          delete env["TMUX"];
+          delete env["TMUX_PANE"];
+          delete env["STY"];
+          delete env["WINDOW"];
+          delete env["WINDOWID"];
+          delete env["TERMCAP"];
+          delete env["COLUMNS"];
+          delete env["LINES"];
+        };
+        return UnixTerminal2;
+      })(terminal_1.Terminal)
+    );
+    exports.UnixTerminal = UnixTerminal;
+    var CustomWriteStream = (
+      /** @class */
+      (function() {
+        function CustomWriteStream2(_fd, _encoding) {
+          this._fd = _fd;
+          this._encoding = _encoding;
+          this._writeQueue = [];
+        }
+        CustomWriteStream2.prototype.dispose = function() {
+          clearImmediate(this._writeImmediate);
+          this._writeImmediate = void 0;
+        };
+        CustomWriteStream2.prototype.write = function(data) {
+          var buffer = typeof data === "string" ? Buffer.from(data, this._encoding) : Buffer.from(data);
+          if (buffer.byteLength !== 0) {
+            this._writeQueue.push({ buffer, offset: 0 });
+            if (this._writeQueue.length === 1) {
+              this._processWriteQueue();
+            }
+          }
+        };
+        CustomWriteStream2.prototype._processWriteQueue = function() {
+          var _this = this;
+          this._writeImmediate = void 0;
+          if (this._writeQueue.length === 0) {
+            return;
+          }
+          var task = this._writeQueue[0];
+          fs.write(this._fd, task.buffer, task.offset, function(err, written) {
+            if (err) {
+              if ("code" in err && err.code === "EAGAIN") {
+                _this._writeImmediate = setImmediate(function() {
+                  return _this._processWriteQueue();
+                });
+              } else {
+                _this._writeQueue.length = 0;
+                console.error("Unhandled pty write error", err);
+              }
+              return;
+            }
+            task.offset += written;
+            if (task.offset >= task.buffer.byteLength) {
+              _this._writeQueue.shift();
+            }
+            _this._processWriteQueue();
+          });
+        };
+        return CustomWriteStream2;
+      })()
+    );
+  }
+});
+
+// node_modules/node-pty/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/node-pty/lib/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.native = exports.open = exports.createTerminal = exports.fork = exports.spawn = void 0;
+    var utils_1 = require_utils();
+    var terminalCtor;
+    if (process.platform === "win32") {
+      terminalCtor = require_windowsTerminal().WindowsTerminal;
+    } else {
+      terminalCtor = require_unixTerminal().UnixTerminal;
+    }
+    function spawn3(file, args, opt) {
+      return new terminalCtor(file, args, opt);
+    }
+    exports.spawn = spawn3;
+    function fork(file, args, opt) {
+      return new terminalCtor(file, args, opt);
+    }
+    exports.fork = fork;
+    function createTerminal(file, args, opt) {
+      return new terminalCtor(file, args, opt);
+    }
+    exports.createTerminal = createTerminal;
+    function open(options) {
+      return terminalCtor.open(options);
+    }
+    exports.open = open;
+    exports.native = process.platform !== "win32" ? utils_1.loadNativeModule("pty").module : null;
+  }
+});
+
+// src/server.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { createServer } from "http";
+import { WebSocketServer, WebSocket } from "ws";
+import crypto from "crypto";
+import os from "os";
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  port: 0,
+  host: "0.0.0.0",
+  enableTunnel: true,
+  tunnelProvider: "localtunnel",
+  maxConnections: 5,
+  heartbeatInterval: 3e4,
+  shell: "/bin/bash",
+  cols: 80,
+  rows: 24,
+  enableTerminal: true,
+  sessionTimeout: 0
+};
+var 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"
+};
+
+// src/terminal.ts
+import { EventEmitter } from "events";
+import { spawn } from "child_process";
+var pty = null;
+try {
+  pty = require_lib();
+} catch {
+}
+var TerminalManager = class extends EventEmitter {
+  config;
+  ptyProcess = null;
+  process = null;
+  running = false;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  /**
+   * Start the terminal
+   */
+  start() {
+    if (this.running) return;
+    const { shell, cols, rows, cwd, env } = this.config;
+    const termEnv = {
+      ...process.env,
+      ...env,
+      TERM: "xterm-256color",
+      COLORTERM: "truecolor"
+    };
+    if (pty) {
+      try {
+        this.ptyProcess = pty.spawn(shell, [], {
+          name: "xterm-256color",
+          cols,
+          rows,
+          cwd: cwd || process.cwd(),
+          env: termEnv
+        });
+        this.ptyProcess.onData((data) => {
+          this.emit("data", data);
+        });
+        this.ptyProcess.onExit(({ exitCode }) => {
+          this.running = false;
+          this.emit("exit", exitCode);
+        });
+        this.running = true;
+        return;
+      } catch (error) {
+        console.warn("node-pty failed, using fallback:", error.message);
+      }
+    }
+    this.process = spawn(shell, [], {
+      cwd: cwd || process.cwd(),
+      env: termEnv,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: true
+    });
+    this.process.stdout?.on("data", (data) => {
+      this.emit("data", data.toString());
+    });
+    this.process.stderr?.on("data", (data) => {
+      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) {
+    if (this.ptyProcess) {
+      this.ptyProcess.write(data);
+    } else if (this.process?.stdin) {
+      this.process.stdin.write(data);
+    }
+  }
+  /**
+   * Resize terminal
+   */
+  resize(cols, rows) {
+    if (this.ptyProcess) {
+      this.ptyProcess.resize(cols, rows);
+    }
+  }
+  /**
+   * Clear terminal
+   */
+  clear() {
+    this.emit("data", "\x1B[2J\x1B[H");
+  }
+  /**
+   * Kill terminal process
+   */
+  destroy() {
+    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() {
+    return this.running;
+  }
+  /**
+   * Check if using PTY
+   */
+  hasPty() {
+    return this.ptyProcess !== null;
+  }
+};
+
+// src/tunnel.ts
+import { spawn as spawn2 } from "child_process";
+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-XT32JGNN.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 = spawn2("npx", ["localtunnel", "--port", port.toString()], {
+        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", (data) => {
+        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
+   */
+  createCloudflared(port) {
+    return new Promise((resolve, reject) => {
+      this.process = spawn2(
+        "cloudflared",
+        ["tunnel", "--url", `http://localhost:${port}`],
+        {
+          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 = spawn2("ngrok", ["http", port.toString(), "--log=stdout"], {
+        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", (data) => {
+        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}`));
+        }
+      });
+    });
+  }
+};
+async function checkTunnelAvailability(provider) {
+  try {
+    const { execSync } = await import("child_process");
+    switch (provider) {
+      case "localtunnel":
+        try {
+          await import("./localtunnel-XT32JGNN.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/web-client.ts
+function getWebClient() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+  <meta name="apple-mobile-web-app-capable" content="yes">
+  <meta name="mobile-web-app-capable" content="yes">
+  <meta name="theme-color" content="#0d1117">
+  <title>NikCLI Remote</title>
+  <style>
+    :root {
+      --bg: #0d1117;
+      --bg-secondary: #161b22;
+      --fg: #e6edf3;
+      --fg-muted: #8b949e;
+      --accent: #58a6ff;
+      --success: #3fb950;
+      --warning: #d29922;
+      --error: #f85149;
+      --border: #30363d;
+      --font-mono: 'SF Mono', 'Fira Code', 'Consolas', monospace;
+    }
+
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+      -webkit-tap-highlight-color: transparent;
+    }
+
+    html, body {
+      height: 100%;
+      background: var(--bg);
+      color: var(--fg);
+      font-family: var(--font-mono);
+      font-size: 14px;
+      overflow: hidden;
+      touch-action: manipulation;
+    }
+
+    #app {
+      display: flex;
+      flex-direction: column;
+      height: 100%;
+      height: 100dvh;
+    }
+
+    /* Header */
+    #header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 12px 16px;
+      background: var(--bg-secondary);
+      border-bottom: 1px solid var(--border);
+      flex-shrink: 0;
+    }
+
+    #header h1 {
+      font-size: 16px;
+      font-weight: 600;
+      color: var(--accent);
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    #header h1::before {
+      content: '';
+      width: 10px;
+      height: 10px;
+      background: var(--accent);
+      border-radius: 2px;
+    }
+
+    #status {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      font-size: 12px;
+      color: var(--fg-muted);
+    }
+
+    #status-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: var(--error);
+      transition: background 0.3s;
+    }
+
+    #status-dot.connected {
+      background: var(--success);
+    }
+
+    #status-dot.connecting {
+      background: var(--warning);
+      animation: pulse 1s infinite;
+    }
+
+    @keyframes pulse {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.5; }
+    }
+
+    /* Terminal */
+    #terminal-container {
+      flex: 1;
+      overflow: hidden;
+      position: relative;
+    }
+
+    #terminal {
+      height: 100%;
+      padding: 12px;
+      overflow-y: auto;
+      overflow-x: hidden;
+      font-size: 13px;
+      line-height: 1.5;
+      white-space: pre-wrap;
+      word-break: break-all;
+      -webkit-overflow-scrolling: touch;
+    }
+
+    #terminal::-webkit-scrollbar {
+      width: 6px;
+    }
+
+    #terminal::-webkit-scrollbar-track {
+      background: var(--bg);
+    }
+
+    #terminal::-webkit-scrollbar-thumb {
+      background: var(--border);
+      border-radius: 3px;
+    }
+
+    .cursor {
+      display: inline-block;
+      width: 8px;
+      height: 16px;
+      background: var(--fg);
+      animation: blink 1s step-end infinite;
+      vertical-align: text-bottom;
+    }
+
+    @keyframes blink {
+      50% { opacity: 0; }
+    }
+
+    /* Notifications */
+    #notifications {
+      position: fixed;
+      top: 60px;
+      left: 12px;
+      right: 12px;
+      z-index: 1000;
+      pointer-events: none;
+    }
+
+    .notification {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 12px 16px;
+      margin-bottom: 8px;
+      animation: slideIn 0.3s ease;
+      pointer-events: auto;
+      box-shadow: 0 4px 12px rgba(0,0,0,0.4);
+    }
+
+    .notification.success { border-left: 3px solid var(--success); }
+    .notification.error { border-left: 3px solid var(--error); }
+    .notification.warning { border-left: 3px solid var(--warning); }
+    .notification.info { border-left: 3px solid var(--accent); }
+
+    .notification h4 {
+      font-size: 14px;
+      font-weight: 600;
+      margin-bottom: 4px;
+    }
+
+    .notification p {
+      font-size: 12px;
+      color: var(--fg-muted);
+    }
+
+    @keyframes slideIn {
+      from { transform: translateY(-20px); opacity: 0; }
+      to { transform: translateY(0); opacity: 1; }
+    }
+
+    /* Quick Keys */
+    #quickkeys {
+      display: grid;
+      grid-template-columns: repeat(6, 1fr);
+      gap: 6px;
+      padding: 8px 12px;
+      background: var(--bg-secondary);
+      border-top: 1px solid var(--border);
+      flex-shrink: 0;
+    }
+
+    .qkey {
+      background: var(--bg);
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      padding: 10px 4px;
+      color: var(--fg);
+      font-size: 11px;
+      font-family: var(--font-mono);
+      text-align: center;
+      cursor: pointer;
+      user-select: none;
+      transition: background 0.1s, transform 0.1s;
+    }
+
+    .qkey:active {
+      background: var(--border);
+      transform: scale(0.95);
+    }
+
+    .qkey.wide {
+      grid-column: span 2;
+    }
+
+    .qkey.accent {
+      background: var(--accent);
+      border-color: var(--accent);
+      color: #fff;
+    }
+
+    /* Input */
+    #input-container {
+      padding: 12px;
+      background: var(--bg-secondary);
+      border-top: 1px solid var(--border);
+      flex-shrink: 0;
+    }
+
+    #input-row {
+      display: flex;
+      gap: 8px;
+    }
+
+    #input {
+      flex: 1;
+      background: var(--bg);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 12px 14px;
+      color: var(--fg);
+      font-family: var(--font-mono);
+      font-size: 16px;
+      outline: none;
+      transition: border-color 0.2s;
+    }
+
+    #input:focus {
+      border-color: var(--accent);
+    }
+
+    #input::placeholder {
+      color: var(--fg-muted);
+    }
+
+    #send {
+      background: var(--accent);
+      color: #fff;
+      border: none;
+      border-radius: 8px;
+      padding: 12px 20px;
+      font-size: 14px;
+      font-weight: 600;
+      font-family: var(--font-mono);
+      cursor: pointer;
+      transition: opacity 0.2s, transform 0.1s;
+    }
+
+    #send:active {
+      opacity: 0.8;
+      transform: scale(0.98);
+    }
+
+    /* Auth Screen */
+    #auth-screen {
+      position: fixed;
+      inset: 0;
+      background: var(--bg);
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 20px;
+      z-index: 2000;
+    }
+
+    #auth-screen.hidden {
+      display: none;
+    }
+
+    .spinner {
+      width: 40px;
+      height: 40px;
+      border: 3px solid var(--border);
+      border-top-color: var(--accent);
+      border-radius: 50%;
+      animation: spin 1s linear infinite;
+    }
+
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+
+    #auth-screen p {
+      color: var(--fg-muted);
+      font-size: 14px;
+    }
+
+    #auth-screen .error {
+      color: var(--error);
+    }
+
+    /* Safe area padding for notched devices */
+    @supports (padding: env(safe-area-inset-bottom)) {
+      #input-container {
+        padding-bottom: calc(12px + env(safe-area-inset-bottom));
+      }
+    }
+
+    /* Landscape adjustments */
+    @media (max-height: 500px) {
+      #quickkeys {
+        grid-template-columns: repeat(12, 1fr);
+        padding: 6px 8px;
+      }
+      .qkey {
+        padding: 8px 2px;
+        font-size: 10px;
+      }
+      #terminal {
+        font-size: 12px;
+      }
+    }
+  </style>
+</head>
+<body>
+  <div id="app">
+    <div id="auth-screen">
+      <div class="spinner"></div>
+      <p id="auth-status">Connecting to NikCLI...</p>
+    </div>
+
+    <header id="header">
+      <h1>NikCLI Remote</h1>
+      <div id="status">
+        <span id="status-dot" class="connecting"></span>
+        <span id="status-text">Connecting</span>
+      </div>
+    </header>
+
+    <div id="terminal-container">
+      <div id="terminal"></div>
+    </div>
+
+    <div id="notifications"></div>
+
+    <div id="quickkeys">
+      <button class="qkey" data-key="\\t">Tab</button>
+      <button class="qkey" data-key="\\x1b[A">\u2191</button>
+      <button class="qkey" data-key="\\x1b[B">\u2193</button>
+      <button class="qkey" data-key="\\x1b[D">\u2190</button>
+      <button class="qkey" data-key="\\x1b[C">\u2192</button>
+      <button class="qkey" data-key="\\x1b">Esc</button>
+      <button class="qkey" data-key="\\x03">^C</button>
+      <button class="qkey" data-key="\\x04">^D</button>
+      <button class="qkey" data-key="\\x1a">^Z</button>
+      <button class="qkey" data-key="\\x0c">^L</button>
+      <button class="qkey wide accent" data-key="\\r">Enter \u23CE</button>
+    </div>
+
+    <div id="input-container">
+      <div id="input-row">
+        <input type="text" id="input" placeholder="Type command..." autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false">
+        <button id="send">Send</button>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    (function() {
+      'use strict';
+
+      // Parse URL params
+      const params = new URLSearchParams(location.search);
+      const token = params.get('t');
+      const sessionId = params.get('s');
+
+      // DOM elements
+      const terminal = document.getElementById('terminal');
+      const input = document.getElementById('input');
+      const sendBtn = document.getElementById('send');
+      const statusDot = document.getElementById('status-dot');
+      const statusText = document.getElementById('status-text');
+      const authScreen = document.getElementById('auth-screen');
+      const authStatus = document.getElementById('auth-status');
+      const notifications = document.getElementById('notifications');
+
+      // State
+      let ws = null;
+      let reconnectAttempts = 0;
+      const maxReconnectAttempts = 5;
+      let terminalEnabled = true;
+
+      // Connect to WebSocket
+      function connect() {
+        const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+        ws = new WebSocket(protocol + '//' + location.host);
+
+        ws.onopen = function() {
+          setStatus('connecting', 'Authenticating...');
+          ws.send(JSON.stringify({ type: 'auth', token: token }));
+        };
+
+        ws.onmessage = function(event) {
+          try {
+            const msg = JSON.parse(event.data);
+            handleMessage(msg);
+          } catch (e) {
+            console.error('Parse error:', e);
+          }
+        };
+
+        ws.onclose = function() {
+          setStatus('disconnected', 'Disconnected');
+          if (reconnectAttempts < maxReconnectAttempts) {
+            reconnectAttempts++;
+            const delay = Math.min(2000 * reconnectAttempts, 10000);
+            setTimeout(connect, delay);
+          } else {
+            authStatus.textContent = 'Connection failed. Refresh to retry.';
+            authStatus.classList.add('error');
+            authScreen.classList.remove('hidden');
+          }
+        };
+
+        ws.onerror = function() {
+          console.error('WebSocket error');
+        };
+      }
+
+      // Handle incoming message
+      function handleMessage(msg) {
+        switch (msg.type) {
+          case 'auth:required':
+            // Already sent auth on open
+            break;
+
+          case 'auth:success':
+            authScreen.classList.add('hidden');
+            setStatus('connected', 'Connected');
+            reconnectAttempts = 0;
+            terminalEnabled = msg.payload?.terminalEnabled !== false;
+            if (terminalEnabled) {
+              appendOutput('\\x1b[32mConnected to NikCLI\\x1b[0m\\n\\n');
+            }
+            break;
+
+          case 'auth:failed':
+            authStatus.textContent = 'Authentication failed';
+            authStatus.classList.add('error');
+            break;
+
+          case 'terminal:output':
+            if (msg.payload?.data) {
+              appendOutput(msg.payload.data);
+            }
+            break;
+
+          case 'terminal:exit':
+            appendOutput('\\n\\x1b[33m[Process exited with code ' + (msg.payload?.code || 0) + ']\\x1b[0m\\n');
+            break;
+
+          case 'notification':
+            showNotification(msg.payload);
+            break;
+
+          case 'session:end':
+            appendOutput('\\n\\x1b[31m[Session ended]\\x1b[0m\\n');
+            setStatus('disconnected', 'Session ended');
+            break;
+
+          case 'pong':
+            // Heartbeat response
+            break;
+
+          default:
+            console.log('Unknown message:', msg.type);
+        }
+      }
+
+      // Append text to terminal with ANSI support
+      function appendOutput(text) {
+        // Simple ANSI to HTML conversion
+        const html = ansiToHtml(text);
+        terminal.innerHTML += html;
+        terminal.scrollTop = terminal.scrollHeight;
+      }
+
+      // Basic ANSI to HTML
+      function ansiToHtml(text) {
+        const ansiColors = {
+          '30': '#6e7681', '31': '#f85149', '32': '#3fb950', '33': '#d29922',
+          '34': '#58a6ff', '35': '#bc8cff', '36': '#76e3ea', '37': '#e6edf3',
+          '90': '#6e7681', '91': '#f85149', '92': '#3fb950', '93': '#d29922',
+          '94': '#58a6ff', '95': '#bc8cff', '96': '#76e3ea', '97': '#ffffff'
+        };
+
+        let result = '';
+        let currentStyle = '';
+
+        const parts = text.split(/\\x1b\\[([0-9;]+)m/);
+        for (let i = 0; i < parts.length; i++) {
+          if (i % 2 === 0) {
+            // Text content
+            result += escapeHtml(parts[i]);
+          } else {
+            // ANSI code
+            const codes = parts[i].split(';');
+            for (const code of codes) {
+              if (code === '0') {
+                if (currentStyle) {
+                  result += '</span>';
+                  currentStyle = '';
+                }
+              } else if (code === '1') {
+                currentStyle = 'font-weight:bold;';
+                result += '<span style="' + currentStyle + '">';
+              } else if (ansiColors[code]) {
+                if (currentStyle) result += '</span>';
+                currentStyle = 'color:' + ansiColors[code] + ';';
+                result += '<span style="' + currentStyle + '">';
+              }
+            }
+          }
+        }
+
+        if (currentStyle) result += '</span>';
+        return result;
+      }
+
+      // Escape HTML
+      function escapeHtml(text) {
+        return text
+          .replace(/&/g, '&amp;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;')
+          .replace(/\\n/g, '<br>')
+          .replace(/ /g, '&nbsp;');
+      }
+
+      // Set connection status
+      function setStatus(state, text) {
+        statusDot.className = state === 'connected' ? 'connected' :
+                              state === 'connecting' ? 'connecting' : '';
+        statusText.textContent = text;
+      }
+
+      // Send data to terminal
+      function send(data) {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'terminal:input', data: data }));
+        }
+      }
+
+      // Show notification
+      function showNotification(n) {
+        if (!n) return;
+        const el = document.createElement('div');
+        el.className = 'notification ' + (n.type || 'info');
+        el.innerHTML = '<h4>' + escapeHtml(n.title || 'Notification') + '</h4>' +
+                       '<p>' + escapeHtml(n.body || '') + '</p>';
+        notifications.appendChild(el);
+        setTimeout(function() { el.remove(); }, 5000);
+      }
+
+      // Event: Send button
+      sendBtn.onclick = function() {
+        if (input.value) {
+          send(input.value + '\\r');
+          input.value = '';
+        }
+        input.focus();
+      };
+
+      // Event: Enter key in input
+      input.onkeydown = function(e) {
+        if (e.key === 'Enter') {
+          e.preventDefault();
+          sendBtn.click();
+        }
+      };
+
+      // Event: Quick keys
+      document.querySelectorAll('.qkey').forEach(function(btn) {
+        btn.onclick = function() {
+          const key = btn.dataset.key;
+          const decoded = key
+            .replace(/\\\\x([0-9a-f]{2})/gi, function(_, hex) {
+              return String.fromCharCode(parseInt(hex, 16));
+            })
+            .replace(/\\\\t/g, '\\t')
+            .replace(/\\\\r/g, '\\r')
+            .replace(/\\\\n/g, '\\n');
+          send(decoded);
+          input.focus();
+        };
+      });
+
+      // Heartbeat
+      setInterval(function() {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'ping' }));
+        }
+      }, 25000);
+
+      // Handle resize
+      function sendResize() {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          const cols = Math.floor(terminal.clientWidth / 8);
+          const rows = Math.floor(terminal.clientHeight / 18);
+          ws.send(JSON.stringify({ type: 'terminal:resize', cols: cols, rows: rows }));
+        }
+      }
+
+      window.addEventListener('resize', sendResize);
+      setTimeout(sendResize, 1000);
+
+      // Start connection
+      if (token) {
+        connect();
+      } else {
+        authStatus.textContent = 'Invalid session URL';
+        authStatus.classList.add('error');
+      }
+    })();
+  </script>
+</body>
+</html>`;
+}
+
+// src/server.ts
+var RemoteServer = class extends EventEmitter2 {
+  config;
+  httpServer = null;
+  wss = null;
+  clients = /* @__PURE__ */ new Map();
+  session = null;
+  terminal = null;
+  tunnel = null;
+  heartbeatTimer = null;
+  sessionTimeoutTimer = null;
+  isRunning = false;
+  sessionSecret;
+  constructor(config = {}) {
+    super();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.sessionSecret = config.sessionSecret || this.generateSecret();
+  }
+  /**
+   * Start the remote server
+   */
+  async start(options = {}) {
+    if (this.isRunning) {
+      throw new Error("Server already running");
+    }
+    const sessionId = this.generateSessionId();
+    this.httpServer = createServer((req, res) => this.handleHttpRequest(req, res));
+    this.wss = new WebSocketServer({ server: this.httpServer });
+    this.setupWebSocketHandlers();
+    const port = await new Promise((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);
+    });
+    const localIp = this.getLocalIP();
+    const localUrl = `http://${localIp}:${port}`;
+    this.session = {
+      id: sessionId,
+      name: options.name || `nikcli-${sessionId}`,
+      qrCode: "",
+      qrUrl: localUrl,
+      localUrl,
+      status: "starting",
+      connectedDevices: [],
+      startedAt: /* @__PURE__ */ new Date(),
+      lastActivity: /* @__PURE__ */ new Date(),
+      port
+    };
+    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) {
+        this.emit("tunnel:error", error);
+        this.session.qrUrl = `${localUrl}?s=${sessionId}&t=${this.sessionSecret}`;
+      }
+    } else {
+      this.session.qrUrl = `${localUrl}?s=${sessionId}&t=${this.sessionSecret}`;
+    }
+    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) => {
+        this.broadcast({ type: MessageTypes.TERMINAL_OUTPUT, payload: { data } });
+      });
+      this.terminal.on("exit", (code) => {
+        this.broadcast({ type: MessageTypes.TERMINAL_EXIT, payload: { code } });
+      });
+    }
+    this.startHeartbeat();
+    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() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.sessionTimeoutTimer) {
+      clearTimeout(this.sessionTimeoutTimer);
+      this.sessionTimeoutTimer = null;
+    }
+    this.broadcast({ type: MessageTypes.SESSION_END, payload: {} });
+    for (const client of this.clients.values()) {
+      client.ws.close(1e3, "Server shutting down");
+    }
+    this.clients.clear();
+    if (this.terminal) {
+      this.terminal.destroy();
+      this.terminal = null;
+    }
+    if (this.tunnel) {
+      await this.tunnel.close();
+      this.tunnel = null;
+    }
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+    if (this.httpServer) {
+      await new Promise((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) {
+    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) {
+    this.broadcast({
+      type: MessageTypes.NOTIFICATION,
+      payload: notification
+    });
+  }
+  /**
+   * Get current session
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Check if server is running
+   */
+  isActive() {
+    return this.isRunning && this.session?.status !== "stopped";
+  }
+  /**
+   * Get connected client count
+   */
+  getConnectedCount() {
+    let count = 0;
+    for (const client of this.clients.values()) {
+      if (client.authenticated) count++;
+    }
+    return count;
+  }
+  /**
+   * Write to terminal
+   */
+  writeToTerminal(data) {
+    this.terminal?.write(data);
+  }
+  /**
+   * Resize terminal
+   */
+  resizeTerminal(cols, rows) {
+    this.terminal?.resize(cols, rows);
+  }
+  /**
+   * Setup WebSocket handlers
+   */
+  setupWebSocketHandlers() {
+    this.wss.on("connection", (ws, req) => {
+      const clientId = this.generateClientId();
+      const client = {
+        id: clientId,
+        ws,
+        authenticated: false,
+        device: {
+          id: clientId,
+          userAgent: req.headers["user-agent"],
+          ip: req.socket.remoteAddress,
+          connectedAt: /* @__PURE__ */ new Date(),
+          lastActivity: /* @__PURE__ */ new Date()
+        },
+        lastPing: Date.now()
+      };
+      if (this.clients.size >= this.config.maxConnections) {
+        ws.close(1013, "Max connections reached");
+        return;
+      }
+      this.clients.set(clientId, client);
+      ws.send(JSON.stringify({ type: MessageTypes.AUTH_REQUIRED, timestamp: Date.now() }));
+      ws.on("message", (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          this.handleClientMessage(client, message);
+        } catch {
+        }
+      });
+      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
+   */
+  handleClientMessage(client, message) {
+    client.device.lastActivity = /* @__PURE__ */ new Date();
+    if (this.session) {
+      this.session.lastActivity = /* @__PURE__ */ new Date();
+    }
+    if (this.config.sessionTimeout > 0) {
+      this.resetSessionTimeout();
+    }
+    switch (message.type) {
+      case MessageTypes.AUTH:
+        this.handleAuth(client, message.token);
+        break;
+      case MessageTypes.TERMINAL_INPUT:
+        if (client.authenticated && message.data) {
+          this.terminal?.write(message.data);
+        }
+        break;
+      case MessageTypes.TERMINAL_RESIZE:
+        if (client.authenticated && message.cols && message.rows) {
+          this.terminal?.resize(message.cols, message.rows);
+        }
+        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,
+            args: message.args
+          });
+        }
+        break;
+      default:
+        this.emit("message", client, message);
+    }
+  }
+  /**
+   * Handle authentication
+   */
+  handleAuth(client, token) {
+    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()
+        })
+      );
+      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
+   */
+  handleHttpRequest(req, res) {
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    const path = url.pathname;
+    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;
+    }
+    if (path === "/" || path === "/index.html") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(getWebClient());
+      return;
+    }
+    if (path === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", session: this.session?.id }));
+      return;
+    }
+    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
+   */
+  startHeartbeat() {
+    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
+   */
+  startSessionTimeout() {
+    this.sessionTimeoutTimer = setTimeout(() => {
+      if (this.session?.connectedDevices.length === 0) {
+        this.stop();
+      }
+    }, this.config.sessionTimeout);
+  }
+  /**
+   * Reset session timeout
+   */
+  resetSessionTimeout() {
+    if (this.sessionTimeoutTimer) {
+      clearTimeout(this.sessionTimeoutTimer);
+    }
+    if (this.config.sessionTimeout > 0) {
+      this.startSessionTimeout();
+    }
+  }
+  /**
+   * Get local IP
+   */
+  getLocalIP() {
+    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
+   */
+  generateSessionId() {
+    return crypto.randomBytes(4).toString("hex");
+  }
+  /**
+   * Generate client ID
+   */
+  generateClientId() {
+    return "c_" + crypto.randomBytes(4).toString("hex");
+  }
+  /**
+   * Generate secret
+   */
+  generateSecret() {
+    return crypto.randomBytes(16).toString("hex");
+  }
+};
+
+export {
+  DEFAULT_CONFIG,
+  MessageTypes,
+  TerminalManager,
+  TunnelManager,
+  checkTunnelAvailability,
+  findAvailableTunnel,
+  getWebClient,
+  RemoteServer
+};