quvur-dev 1.0.0

package/dist/index.cjs

@@ -0,0 +1,789 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/commands/index.ts
+var import_commander7 = require("commander");
+
+// src/core/ws-client.ts
+var import_ws = require("ws");
+
+// src/utils/config.ts
+var path = __toESM(require("path"), 1);
+var fs = __toESM(require("fs"), 1);
+var os = __toESM(require("os"), 1);
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var logger = {
+  info: (...msg) => console.log(import_chalk.default.blue("[\u2139]"), ...msg),
+  next: (...msg) => console.log(import_chalk.default.green("[\u2192]"), ...msg),
+  success: (...msg) => console.log(import_chalk.default.green("[\u2714]"), ...msg),
+  error: (...msg) => console.error(import_chalk.default.red("[\u2716]"), ...msg),
+  debug: (...msg) => console.debug(import_chalk.default.bgRed("[debug]"), ...msg),
+  warn: (...msg) => console.warn(import_chalk.default.bgYellowBright("[warn]"), ...msg),
+  log: (...msg) => console.log(...msg)
+};
+
+// src/utils/config.ts
+var localConfigPath = path.join(process.cwd(), "config.json");
+var configDir = path.join(os.homedir(), ".quvur");
+var configPath = path.join(os.homedir(), ".quvur", "config.json");
+var loadConfig = () => {
+  if (!fs.existsSync(configPath)) {
+    if (fs.existsSync(localConfigPath)) {
+      return loadConfigFromLocal();
+    }
+    throw new Error("Config file not found. Run `quvur auth` first.");
+  }
+  const raw = fs.readFileSync(configPath, "utf-8");
+  try {
+    const config2 = JSON.parse(raw);
+    return config2;
+  } catch (error) {
+    throw new Error("Invalid config file. Run `quvur auth` first.");
+  }
+};
+var loadConfigFromLocal = () => {
+  const raw = fs.readFileSync(localConfigPath, "utf-8");
+  try {
+    const config2 = JSON.parse(raw);
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(configPath, raw);
+    return config2;
+  } catch (error) {
+    logger.error(error);
+    throw new Error("Invalid config file");
+  }
+};
+var saveConfig = (config2) => {
+  fs.writeFileSync(configPath, JSON.stringify(config2, null, 2));
+};
+var config = loadConfig();
+
+// src/auth/token-manager.ts
+var import_axios = __toESM(require("axios"), 1);
+var TokenManager = class {
+  async getValidAccessToken() {
+    const { accessToken, refreshToken } = config.auth;
+    if (!accessToken) {
+      logger.error("No access token found. Please authenticate first.");
+      return null;
+    }
+    try {
+      await this.tokenExchange(accessToken);
+      logger.debug("Token exchanged");
+      return accessToken;
+    } catch (error) {
+      if (refreshToken) {
+        try {
+          const newAccessToken = await this.refreshTokens(refreshToken);
+          logger.debug("Token refreshed");
+          return newAccessToken;
+        } catch (error2) {
+          if (error2 instanceof Error) {
+            logger.error(`Failed to refresh tokens: ${error2.message}`);
+          }
+          this.clearTokens();
+          return null;
+        }
+      }
+      if (error instanceof Error) {
+        logger.error(`Unauthorized. ${error.message}`);
+      } else {
+        logger.error("Error during token exchange");
+      }
+      return null;
+    }
+  }
+  saveTokens(accessToken, refreshToken) {
+    config.auth.accessToken = accessToken;
+    config.auth.refreshToken = refreshToken;
+    saveConfig(config);
+  }
+  clearTokens() {
+    config.auth.accessToken = null;
+    config.auth.refreshToken = null;
+    saveConfig(config);
+  }
+  async refreshTokens(refreshToken) {
+    try {
+      const response = await import_axios.default.post(
+        `${config.apiBaseUrl}/auth/refresh-token`,
+        { refresh_token: refreshToken }
+      );
+      const { data: tokens } = response;
+      config.auth = {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token
+      };
+      saveConfig(config);
+      return tokens.access_token;
+    } catch (error) {
+      if (error instanceof import_axios.AxiosError) {
+        const errorData = error.response?.data;
+        if (!errorData) throw error;
+        throw new Error(errorData.error);
+      }
+      throw error;
+    }
+  }
+  async tokenExchange(accessToken) {
+    try {
+      const response = await import_axios.default.post(
+        `${config.apiBaseUrl}/auth/token-exchange`,
+        {
+          access_token: accessToken
+        }
+      );
+      const { data } = response;
+      return data.access_token;
+    } catch (error) {
+      if (error instanceof import_axios.AxiosError) {
+        const errorData = error.response?.data;
+        if (!errorData) throw error;
+        throw new Error(errorData.error);
+      }
+      throw error;
+    }
+  }
+};
+var tokenManager = new TokenManager();
+
+// src/core/ws-client.ts
+var connectWebSocket = async (data) => {
+  const url = new URL(config.wsBaseUrl);
+  Object.entries(data).forEach(([key, value]) => {
+    if (value) url.searchParams.set(key, String(value));
+  });
+  const accessToken = await tokenManager.getValidAccessToken();
+  if (!accessToken) return null;
+  const ws = new import_ws.WebSocket(url, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`
+    }
+  });
+  return ws;
+};
+
+// src/transport/http-tunnel.ts
+var import_node_http = __toESM(require("http"), 1);
+var import_ws3 = require("ws");
+
+// src/@protocol/binary-frame.ts
+var encodeBinaryFrame = (frame) => {
+  const idBuf = Buffer.from(frame.requestId);
+  const idLen = Buffer.alloc(4);
+  idLen.writeUInt32BE(idBuf.length);
+  return Buffer.concat([idLen, idBuf, frame.chunk]);
+};
+var decodeBinaryFrame = (buffer) => {
+  const idLen = buffer.readUInt32BE(0);
+  const idStart = 4;
+  const idEnd = 4 + idLen;
+  if (buffer.length <= idEnd) return null;
+  const requestId = buffer.subarray(idStart, idEnd).toString();
+  const chunk = buffer.subarray(idEnd);
+  return { requestId, chunk };
+};
+
+// src/@protocol/schemas/index.ts
+var import_zod6 = __toESM(require("zod"), 1);
+
+// src/@protocol/schemas/request.schema.ts
+var import_zod2 = __toESM(require("zod"), 1);
+
+// src/@protocol/schemas/base.schema.ts
+var import_zod = __toESM(require("zod"), 1);
+
+// src/@protocol/constants.ts
+var PROTOCOL_VERSION = "1.0.0";
+var JsonMessageType = /* @__PURE__ */ ((JsonMessageType2) => {
+  JsonMessageType2["CreateDeviceSession"] = "create-device-session";
+  JsonMessageType2["AuthSuccess"] = "auth-success";
+  JsonMessageType2["AuthError"] = "auth-error";
+  JsonMessageType2["RequestStart"] = "request-start";
+  JsonMessageType2["RequestEnd"] = "request-end";
+  JsonMessageType2["ResponseStart"] = "response-start";
+  JsonMessageType2["ResponseEnd"] = "response-end";
+  JsonMessageType2["TunnelCreated"] = "tunnel-created";
+  JsonMessageType2["Error"] = "error";
+  return JsonMessageType2;
+})(JsonMessageType || {});
+
+// src/@protocol/schemas/base.schema.ts
+var baseSchema = import_zod.default.object({
+  version: import_zod.default.string().default(PROTOCOL_VERSION),
+  type: import_zod.default.enum(JsonMessageType)
+});
+
+// src/@protocol/schemas/request.schema.ts
+var requestStartSchema = baseSchema.extend({
+  type: import_zod2.default.literal("request-start" /* RequestStart */),
+  requestId: import_zod2.default.string(),
+  method: import_zod2.default.string(),
+  url: import_zod2.default.string(),
+  headers: import_zod2.default.record(import_zod2.default.string(), import_zod2.default.string())
+});
+var requestEndSchema = baseSchema.extend({
+  type: import_zod2.default.literal("request-end" /* RequestEnd */),
+  requestId: import_zod2.default.string()
+});
+
+// src/@protocol/schemas/response.schema.ts
+var import_zod3 = __toESM(require("zod"), 1);
+var responseStartSchema = baseSchema.extend({
+  type: import_zod3.default.literal("response-start" /* ResponseStart */),
+  requestId: import_zod3.default.string(),
+  statusCode: import_zod3.default.number().int().min(100).max(599),
+  headers: import_zod3.default.record(import_zod3.default.string(), import_zod3.default.string())
+});
+var responseEndSchema = baseSchema.extend({
+  type: import_zod3.default.literal("response-end" /* ResponseEnd */),
+  requestId: import_zod3.default.string()
+});
+
+// src/@protocol/schemas/tunnel.schema.ts
+var import_zod4 = __toESM(require("zod"), 1);
+var tunnelCreatedSchema = baseSchema.extend({
+  type: import_zod4.default.literal("tunnel-created" /* TunnelCreated */),
+  tunnelId: import_zod4.default.string(),
+  subdomain: import_zod4.default.string(),
+  host: import_zod4.default.string()
+});
+
+// src/@protocol/schemas/error-schema.ts
+var import_zod5 = __toESM(require("zod"), 1);
+var errorSchema = baseSchema.extend({
+  type: import_zod5.default.literal("error" /* Error */),
+  message: import_zod5.default.string()
+});
+
+// src/@protocol/schemas/index.ts
+var jsonMessageSchema = import_zod6.default.discriminatedUnion("type", [
+  requestStartSchema,
+  requestEndSchema,
+  responseStartSchema,
+  responseEndSchema,
+  tunnelCreatedSchema,
+  errorSchema
+]);
+
+// src/@protocol/logger/index.ts
+var import_chalk2 = __toESM(require("chalk"), 1);
+var protoLogger = {
+  info: (...msg) => console.log(
+    import_chalk2.default.blue("[protocol:info]"),
+    ...msg,
+    (/* @__PURE__ */ new Date()).toLocaleString(),
+    "\n"
+  ),
+  next: (...msg) => console.log(
+    import_chalk2.default.green("[protocol:next]"),
+    ...msg,
+    (/* @__PURE__ */ new Date()).toLocaleString(),
+    "\n"
+  ),
+  success: (...msg) => console.log(
+    import_chalk2.default.green("[protocol:success]"),
+    ...msg,
+    (/* @__PURE__ */ new Date()).toLocaleString(),
+    "\n"
+  ),
+  error: (...msg) => console.error(
+    import_chalk2.default.red("[protocol:error]"),
+    ...msg,
+    (/* @__PURE__ */ new Date()).toLocaleString(),
+    "\n"
+  ),
+  debug: (...msg) => console.debug(
+    import_chalk2.default.bgRed("[protocol:debug]"),
+    ...msg,
+    (/* @__PURE__ */ new Date()).toLocaleString(),
+    "\n"
+  ),
+  warn: (...msg) => console.warn(
+    import_chalk2.default.bgYellowBright("[protocol:warn]"),
+    ...msg,
+    (/* @__PURE__ */ new Date()).toLocaleString(),
+    "\n"
+  ),
+  log: (...msg) => console.log("[protocol:log]", ...msg, (/* @__PURE__ */ new Date()).toLocaleString(), "\n")
+};
+
+// src/@protocol/parser.ts
+var parseFrame = (data, isBinary) => {
+  if (isBinary) {
+    const decoded = decodeBinaryFrame(data);
+    if (!decoded) return null;
+    return { kind: "binary" /* Binary */, data: decoded };
+  }
+  try {
+    const parsed = JSON.parse(data.toString("utf-8"));
+    const validated = jsonMessageSchema.parse(parsed);
+    return {
+      kind: "json" /* Json */,
+      data: validated
+    };
+  } catch (error) {
+    protoLogger.error("Failed to parse frame:", error);
+    return null;
+  }
+};
+
+// src/@protocol/contract.ts
+var import_ws2 = require("ws");
+function createProtocolSide(incomingSchema, outgoingSchema) {
+  return {
+    validateIncoming: (data) => {
+      try {
+        return incomingSchema.parse(data);
+      } catch (error) {
+        return null;
+      }
+    },
+    sendJson: (ws, message) => {
+      try {
+        const validated = outgoingSchema.parse(message);
+        ws.send(JSON.stringify(validated), { binary: false });
+      } catch (error) {
+        protoLogger.error("Failed to send JSON message:", error);
+        ws.close();
+      }
+    },
+    sendBinary(ws, frame) {
+      const buffer = encodeBinaryFrame(frame);
+      ws.send(buffer, { binary: true });
+    }
+  };
+}
+
+// src/@protocol/directions/client-to-server.ts
+var import_zod7 = __toESM(require("zod"), 1);
+var clientToServerSchema = import_zod7.default.discriminatedUnion("type", [
+  responseStartSchema,
+  responseEndSchema,
+  errorSchema
+]);
+
+// src/@protocol/directions/server-to-client.ts
+var import_zod8 = __toESM(require("zod"), 1);
+var serverToClientSchema = import_zod8.default.discriminatedUnion("type", [
+  tunnelCreatedSchema,
+  requestStartSchema,
+  requestEndSchema,
+  errorSchema
+]);
+
+// src/@protocol/index.ts
+var protocol = createProtocolSide(
+  serverToClientSchema,
+  // incoming
+  clientToServerSchema
+  // outgoing
+);
+
+// src/utils/make-tunnel-url.ts
+var makeTunnelUrl = (host) => {
+  return `http://${host}`;
+};
+
+// src/transport/http-tunnel.ts
+var connections = /* @__PURE__ */ new Map();
+var startHttpTransport = (ws, localPort) => {
+  ws.on("open", () => {
+    logger.info("Creating HTTP tunnel for", `localhost:${localPort}...`);
+  });
+  ws.on("message", (event, isBinary) => {
+    const frame = parseFrame(event, isBinary);
+    if (!frame) {
+      logger.warn("Invalid incoming frame");
+      return;
+    }
+    if (frame.kind === "binary" /* Binary */) {
+      const localRequest = connections.get(frame.data.requestId);
+      if (localRequest) {
+        localRequest.write(frame.data.chunk);
+      }
+      return;
+    }
+    const message = protocol.validateIncoming(frame.data);
+    if (!message) {
+      logger.warn("Invalid direction message");
+      return;
+    }
+    if (message.type === "error" /* Error */) {
+      logger.error(message.message);
+      return ws.close();
+    }
+    if (message.type === "tunnel-created" /* TunnelCreated */) {
+      logger.success("Tunnel ready");
+      logger.next("URL:", makeTunnelUrl(message.host));
+      return;
+    }
+    if (message.type === "request-start" /* RequestStart */) {
+      const localRequest = import_node_http.default.request({
+        hostname: "127.0.0.1",
+        port: localPort,
+        method: message.method,
+        headers: message.headers,
+        path: message.url
+      });
+      connections.set(message.requestId, localRequest);
+      localRequest.on("response", (localResponse) => {
+        protocol.sendJson(ws, {
+          type: "response-start" /* ResponseStart */,
+          version: PROTOCOL_VERSION,
+          requestId: message.requestId,
+          statusCode: localResponse.statusCode || 200,
+          headers: Object(localResponse.headers)
+        });
+        localResponse.on("data", (chunk) => {
+          protocol.sendBinary(ws, { requestId: message.requestId, chunk });
+        });
+        localResponse.on("end", () => {
+          protocol.sendJson(ws, {
+            type: "response-end" /* ResponseEnd */,
+            version: PROTOCOL_VERSION,
+            requestId: message.requestId
+          });
+        });
+      });
+      localRequest.on("error", (error) => {
+        logger.error(`HTTP request error: ${error.message}`);
+        protocol.sendJson(ws, {
+          type: "response-start" /* ResponseStart */,
+          version: PROTOCOL_VERSION,
+          requestId: message.requestId,
+          statusCode: 500,
+          headers: {}
+        });
+        protocol.sendJson(ws, {
+          type: "response-end" /* ResponseEnd */,
+          version: PROTOCOL_VERSION,
+          requestId: message.requestId
+        });
+        ws.close();
+      });
+    } else if (message.type === "request-end" /* RequestEnd */) {
+      const localRequest = connections.get(message.requestId);
+      if (localRequest) {
+        localRequest.end();
+      }
+    }
+  });
+  ws.on("close", () => {
+    logger.info("WebSocket connection closed");
+    process.exit(1);
+  });
+  ws.on("error", (error) => {
+    logger.error(`Websocket error: ${error.message || error}`);
+    process.exit(1);
+  });
+};
+
+// src/core/tunnel.ts
+async function startHttpTunnel(data) {
+  const ws = await connectWebSocket(data);
+  if (!ws) return;
+  startHttpTransport(ws, data.port);
+}
+
+// src/commands/validators/http.validator.ts
+var import_commander = require("commander");
+var validatePort = (value) => {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new import_commander.InvalidArgumentError("port must be an integer");
+  }
+  if (parsed <= 0 || parsed > 65535) {
+    throw new import_commander.InvalidArgumentError("port must be between 1 and 65535");
+  }
+  return parsed;
+};
+var validateSubdomain = (value) => {
+  if (value.length < 3) {
+    throw new import_commander.InvalidArgumentError(
+      "subdomain must be at least 3 characters long"
+    );
+  }
+  if (value.length > 63) {
+    throw new import_commander.InvalidArgumentError("subdomain must be less than 63 characters");
+  }
+  const regex = /^[a-z0-9][a-z0-9-]*$/;
+  if (!regex.test(value)) {
+    throw new import_commander.InvalidArgumentError(
+      "subdomain must contain only lowercase letters, numbers, and hyphens"
+    );
+  }
+  return value;
+};
+
+// src/commands/http.ts
+var registerHttpCommand = (program2, config2) => {
+  program2.command("http").description(config2.description).usage(config2.usage).argument("<port>", "Local port to expose", validatePort).option(
+    "-s, --subdomain <name>",
+    "Request a custom subdomain",
+    validateSubdomain
+  ).addHelpText("after", `Examples:
+  ${config2.examples.join("\n  ")}`).action(async (port, options) => {
+    await startHttpTunnel({
+      port,
+      subdomain: options.subdomain,
+      type: "http" /* http */
+    });
+  });
+};
+
+// src/commands/help.ts
+var import_commander2 = require("commander");
+var registerHelpSubcommand = (program2) => {
+  program2.addHelpText(
+    "after",
+    `
+${config.help.intro}
+
+Examples:
+  ${config.help.examples.join("\n  ")}`
+  );
+};
+
+// src/commands/tcp.ts
+var import_commander3 = require("commander");
+var registerTcpCommand = (program2, config2) => {
+  program2.command("tcp").description(config2.description).usage(config2.usage).argument("<port>", "Local TCP port to expose").option("-t <token>", "Override auth token").addHelpText("after", `
+Examples:
+  ${config2.examples.join("\n  ")}`).action((port, options) => {
+    logger.success("TCP tunnel starting on port:", port);
+    logger.info("Options:", options);
+  });
+};
+
+// src/commands/auth.ts
+var import_commander4 = require("commander");
+
+// src/auth/auth-service.ts
+var import_axios2 = __toESM(require("axios"), 1);
+
+// src/events/auth-emitter.ts
+var import_events = require("events");
+var AuthEventEmitter = class extends import_events.EventEmitter {
+  emit(event, payload) {
+    return super.emit(event, payload);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+};
+var authEmitter = new AuthEventEmitter();
+
+// src/auth/auth-service.ts
+var AuthService = class {
+  async startLogin() {
+    try {
+      authEmitter.emit("auth:start");
+      const response = await import_axios2.default.post(
+        `${config.apiBaseUrl}/auth/github/device-start`
+      );
+      const { data } = response;
+      authEmitter.emit("auth:code", {
+        user_code: data.user_code,
+        verification_uri: data.verification_uri
+      });
+      this.startPolling(data.device_code, data.interval, data.expires_in);
+    } catch (error) {
+      authEmitter.emit("auth:error", error);
+    }
+  }
+  async startPolling(deviceCode, interval, expiresIn) {
+    const expiresAt = /* @__PURE__ */ new Date();
+    expiresAt.setSeconds(expiresAt.getSeconds() + expiresIn);
+    while (Date.now() < expiresAt.getTime()) {
+      try {
+        const response = await import_axios2.default.post(
+          `${config.apiBaseUrl}/auth/github/device-poll`,
+          { device_code: deviceCode }
+        );
+        const { data } = response;
+        authEmitter.emit("auth:success", {
+          accessToken: data.access_token,
+          refreshToken: data.refresh_token,
+          user: data.user
+        });
+        return authEmitter.emit("auth:completed");
+      } catch (error) {
+        if (error instanceof import_axios2.AxiosError) {
+          const errorData = error.response?.data;
+          if (!errorData) {
+            authEmitter.emit("auth:error", error);
+            return;
+          }
+          if (errorData.error === "authorization_pending" /* AUTHORIZATION_PENDING */) {
+            await this.wait(interval);
+            continue;
+          }
+          if (errorData.error === "slow_down" /* SLOW_DOWN */ && errorData.interval) {
+            authEmitter.emit("auth:slow_down");
+            await this.wait(errorData.interval);
+            continue;
+          }
+          if (errorData.error === "expired_token" /* EXPIRED_TOKEN */) {
+            authEmitter.emit("auth:expired");
+            return;
+          }
+          authEmitter.emit(
+            "auth:error",
+            new Error(errorData.error_description)
+          );
+          return;
+        }
+        return authEmitter.emit("auth:error", error);
+      }
+    }
+  }
+  async wait(seconds) {
+    await new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+  }
+  async logout(refreshToken) {
+    try {
+      const response = await import_axios2.default.post(
+        `${config.apiBaseUrl}/auth/logout`,
+        {
+          refresh_token: refreshToken
+        },
+        {
+          headers: {
+            Authorization: `Bearer ${config.auth.accessToken}`
+          }
+        }
+      );
+      return true;
+    } catch (error) {
+      if (error instanceof import_axios2.AxiosError) {
+        const errorData = error.response?.data;
+        if (!errorData) throw error;
+        throw new Error(`Logout failed: ${errorData.error}`);
+      }
+      throw error;
+    }
+  }
+};
+var authService = new AuthService();
+
+// src/commands/auth.ts
+var import_chalk3 = __toESM(require("chalk"), 1);
+var registerAuthCommand = (program2, commandConfig) => {
+  program2.command("auth").description(commandConfig.description).usage(commandConfig.usage).addHelpText(
+    "after",
+    `
+Examples:
+  ${commandConfig.examples.join("\n  ")}`
+  ).action(async () => {
+    authEmitter.on("auth:start", () => {
+      logger.info("Starting GitHub authentication...");
+    });
+    authEmitter.on("auth:code", ({ user_code, verification_uri }) => {
+      logger.info("Please visit the following URL to authorize the CLI:");
+      logger.log(import_chalk3.default.bold.cyan(verification_uri));
+      logger.info(`Enter the code: ${import_chalk3.default.bold.yellow(user_code)}`);
+    });
+    authEmitter.on("auth:success", ({ accessToken, refreshToken, user }) => {
+      tokenManager.saveTokens(accessToken, refreshToken);
+      logger.success(
+        `Successfully authenticated as ${import_chalk3.default.bold.green(`${user.name} (${user.username})`)}!`
+      );
+    });
+    authEmitter.on("auth:error", (error) => {
+      logger.error(`Authentication failed: ${error.message}`);
+      process.exit(1);
+    });
+    authEmitter.on("auth:expired", () => {
+      logger.error("Authentication code expired. Please try again.");
+      process.exit(1);
+    });
+    authEmitter.on("auth:completed", () => {
+      process.exit(0);
+    });
+    await authService.startLogin();
+  });
+};
+
+// src/commands/logout.ts
+var import_commander5 = require("commander");
+var registerLogoutCommand = (program2, commandConfig) => {
+  program2.command("logout").description(commandConfig.description).usage(commandConfig.usage).addHelpText("after", `Examples:
+  ${commandConfig.examples.join("\n  ")}`).action(async () => {
+    const refreshToken = config.auth.refreshToken;
+    if (refreshToken) {
+      try {
+        await authService.logout(refreshToken);
+        logger.success("Logged out successfully.");
+      } catch (error) {
+        if (error instanceof Error) {
+          logger.error("Logout failed:", error.message);
+        } else {
+          logger.error("Logout failed");
+        }
+      } finally {
+        tokenManager.clearTokens();
+      }
+    }
+  });
+};
+
+// src/commands/config.ts
+var import_commander6 = require("commander");
+var registerConfigCommand = (program2, config2) => {
+  program2.command("config").description(config2.description).usage(config2.usage).addHelpText("after", `Examples:
+  ${config2.examples.join("\n  ")}`).option("-r, --reset", "Reset config file options to default.").action((options) => {
+    if (options.reset) {
+      loadConfigFromLocal();
+      logger.success("Config file reset successfully.");
+    } else {
+      loadConfig();
+      logger.success("Config file loaded successfully.");
+    }
+  });
+};
+
+// src/commands/index.ts
+var program = new import_commander7.Command();
+program.name(config.name).version(config.version).description(config.description).usage(config.usage).configureOutput({
+  writeOut: (message) => logger.info(message),
+  writeErr: (message) => logger.error(message)
+});
+registerHttpCommand(program, config.help.commands.http);
+registerTcpCommand(program, config.help.commands.tcp);
+registerAuthCommand(program, config.help.commands.auth);
+registerLogoutCommand(program, config.help.commands.logout);
+registerConfigCommand(program, config.help.commands.config);
+registerHelpSubcommand(program);
+
+// src/index.ts
+process.on("SIGINT", () => {
+  logger.log("\n");
+  logger.warn("Shutting down tunnel...\n");
+  process.exit(0);
+});
+program.parse(process.argv);

package/dist/index.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "quvur-dev",
+  "version": "1.0.0",
+  "description": "",
+  "license": "ISC",
+  "author": "Muhammadali Yuldoshev <mukhammadaliweb@gmail.com>",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "quvur": "dist/index.cjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npx tsup src/index.ts --dts",
+    "start:dev": "tsx --watch src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/axios": "^0.9.36",
+    "@types/node": "^25.2.3",
+    "@types/ws": "^8.18.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "axios": "^1.13.5",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "ws": "^8.19.0",
+    "zod": "^4.3.6"
+  }
+}