'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

const index = require('./shared/gpt-runner-shared.79ccd90a.cjs');
require('minimatch');
require('debug');
const axios = require('axios');
const httpProxyAgent = require('http-proxy-agent');
const httpsProxyAgent = require('https-proxy-agent');
const node_child_process = require('node:child_process');
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');
const getCacheDir = require('cachedir');
const node_url = require('node:url');
require('jsonc-parser');
const launch = require('launch-editor');
const nodeLocalstorage = require('@kvs/node-localstorage');
const open = require('open');
const fp = require('find-free-ports');
const ip = require('ip');
const undici = require('undici');
require('web-streams-polyfill/polyfill');
require('zod-to-json-schema');
require('zod');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }

const axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
const os__default = /*#__PURE__*/_interopDefaultLegacy(os);
const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
const getCacheDir__default = /*#__PURE__*/_interopDefaultLegacy(getCacheDir);
const launch__default = /*#__PURE__*/_interopDefaultLegacy(launch);
const open__default = /*#__PURE__*/_interopDefaultLegacy(open);
const fp__default = /*#__PURE__*/_interopDefaultLegacy(fp);
const ip__default = /*#__PURE__*/_interopDefaultLegacy(ip);

function initAxios() {
  const httpProxyUrl = process.env.HTTP_PROXY;
  const httpsProxyUrl = process.env.HTTPS_PROXY;
  if (httpProxyUrl) {
    const httpAgent = new httpProxyAgent.HttpProxyAgent(httpProxyUrl);
    axios__default.defaults.httpAgent = httpAgent;
  }
  if (httpsProxyUrl) {
    const httpsAgent = new httpsProxyAgent.HttpsProxyAgent(httpsProxyUrl);
    axios__default.defaults.httpsAgent = httpsAgent;
  }
}
let axiosInstance = null;
function getAxiosInstance() {
  if (!axiosInstance) {
    initAxios();
    axiosInstance = axios__default.create();
  }
  return axiosInstance;
}

class PathUtils {
  static getCurrentDirName(importMetaUrl, getDirname) {
    let dirname = "";
    try {
      dirname = getDirname();
    } catch {
    }
    if (!importMetaUrl)
      return index.toUnixPath(dirname);
    const __filename = node_url.fileURLToPath(importMetaUrl);
    const __dirname = path__default.dirname(__filename);
    return __dirname;
  }
  static join(...paths) {
    return index.toUnixPath(path__default.join(...paths));
  }
  static resolve(...paths) {
    return index.toUnixPath(path__default.resolve(...paths));
  }
  static relative(from, to) {
    return index.toUnixPath(path__default.relative(from, to));
  }
  static dirname(filePath) {
    return index.toUnixPath(path__default.dirname(filePath));
  }
  static extname(filePath) {
    if (!PathUtils.isFile(filePath))
      return "";
    return path__default.extname(filePath);
  }
  static isFile(filePath) {
    return fs__default.existsSync(filePath) && fs__default.statSync(filePath).isFile();
  }
  static isDirectory(filePath) {
    return fs__default.existsSync(filePath) && fs__default.statSync(filePath).isDirectory();
  }
  static includeExt(filePath, exts) {
    if (!exts || !Array.isArray(exts))
      return false;
    return exts.some((ext) => filePath.endsWith(ext));
  }
  static isExit(filePath) {
    return fs__default.existsSync(filePath);
  }
  static isAccessible(filePath, mode) {
    if (!PathUtils.isExit(filePath))
      return false;
    const modeMap = {
      F: fs__default.constants.F_OK,
      R: fs__default.constants.R_OK,
      W: fs__default.constants.W_OK,
      X: fs__default.constants.X_OK
    };
    const finalMode = modeMap[mode || "F"] || fs__default.constants.F_OK;
    try {
      fs__default.accessSync(filePath, finalMode);
      return true;
    } catch (err) {
      return false;
    }
  }
  static getDirPath(filePath) {
    return path__default.dirname(filePath);
  }
}

async function getGlobalCacheDir(name) {
  const cacheDir = getCacheDir__default(name);
  await createCacheDir(cacheDir);
  return cacheDir;
}
async function createCacheDir(cacheDir) {
  if (await PathUtils.isAccessible(cacheDir, "W"))
    return;
  await fs__default.promises.mkdir(cacheDir, { recursive: true });
}

const _BinaryDownloader = class {
  static async getBinaryPath() {
    const cacheDir = await getGlobalCacheDir("nicepkg-tunnel");
    const binaryPath = path__default.join(cacheDir, _BinaryDownloader.BINARY_FILENAME);
    return binaryPath;
  }
  static async downloadBinary() {
    const debug = new index.Debug("tunnel");
    const binaryPath = await _BinaryDownloader.getBinaryPath();
    if (!fs__default.existsSync(binaryPath)) {
      const binaryUrl = `https://cdn-media.huggingface.co/frpc-gradio-${_BinaryDownloader.VERSION}/${_BinaryDownloader.BINARY_NAME}${_BinaryDownloader.EXTENSION}`;
      debug.log(`Downloading ${binaryUrl} to ${binaryPath}...`);
      try {
        const axios = getAxiosInstance();
        const response = await axios.get(binaryUrl, {
          responseType: "arraybuffer"
        });
        await fs__default.promises.writeFile(binaryPath, response.data, "binary");
        fs__default.chmodSync(binaryPath, 493);
        debug.log(`Downloaded success ${binaryUrl} to ${binaryPath}`);
      } catch (err) {
        debug.error(`Failed to download ${binaryUrl}: ${err}`);
        if (err?.response?.status === 403) {
          throw new Error(
            `Cannot set up a share link as this platform is incompatible. Please create a GitHub issue with information about your platform: ${JSON.stringify(
              os__default.userInfo()
            )}`
          );
        }
        throw err;
      }
    }
  }
};
let BinaryDownloader = _BinaryDownloader;
BinaryDownloader.VERSION = "0.2";
BinaryDownloader.EXTENSION = os__default.platform() === "win32" ? ".exe" : "";
BinaryDownloader.MACHINE = os__default.arch();
BinaryDownloader.ARCH = _BinaryDownloader.MACHINE === "x64" ? "amd64" : _BinaryDownloader.MACHINE;
BinaryDownloader.BINARY_NAME = `frpc_${os__default.type().toLowerCase()}_${_BinaryDownloader.ARCH.toLowerCase()}`;
BinaryDownloader.BINARY_FILENAME = `${_BinaryDownloader.BINARY_NAME}_v${_BinaryDownloader.VERSION}`;

class TunnelProcess {
  constructor(command) {
    this.proc = null;
    this.command = command;
  }
  async start() {
    const binaryPath = await BinaryDownloader.getBinaryPath();
    await BinaryDownloader.downloadBinary();
    return this._startProcess(binaryPath);
  }
  kill() {
    if (this.proc !== null) {
      this.proc.kill("SIGTERM");
      this.proc = null;
    }
  }
  _startProcess(binary) {
    return new Promise((resolve, reject) => {
      this.proc = node_child_process.spawn(binary, this.command, {
        stdio: ["ignore", "pipe", "pipe"]
      });
      process.once("exit", () => this.kill());
      let output = "";
      this.proc.stdout.on("data", (data) => {
        output += data.toString();
        const match = output.match(/start proxy success: (.+)/);
        if (match) {
          resolve(match[1]);
          output = "";
        }
      });
      this.proc.stderr.on("data", (data) => {
        output += data.toString();
      });
      this.proc.on("error", (err) => {
        reject(err);
      });
    });
  }
}

class Tunnel {
  constructor(options) {
    this.GRADIO_API_SERVER_URL = "https://api.gradio.app/v2/tunnel-request";
    const {
      remoteHost,
      remotePort,
      localHost,
      localPort,
      shareToken
    } = options;
    this.url = null;
    this.remoteHost = remoteHost || "";
    this.remotePort = remotePort || 0;
    this.localHost = localHost || "localhost";
    this.localPort = localPort;
    this.shareToken = shareToken || "";
  }
  async initProcess() {
    if (!this.remoteHost || !this.remotePort) {
      try {
        const axios = getAxiosInstance();
        const res = await axios.get(this.GRADIO_API_SERVER_URL);
        const data = res.data;
        this.remoteHost = data[0].host;
        this.remotePort = data[0].port;
      } catch (err) {
        throw new Error(`Failed to fetch ${this.GRADIO_API_SERVER_URL}: ${index.getErrorMsg(err)}`);
      }
    }
    const command = [
      "http",
      "-n",
      this.shareToken,
      "-l",
      `${this.localPort}`,
      "-i",
      this.localHost,
      "--uc",
      "--sd",
      "random",
      "--ue",
      "--server_addr",
      `${this.remoteHost}:${this.remotePort}`,
      "--disable_log_color"
    ];
    this.tunnelProcess = new TunnelProcess(command);
  }
  async startTunnel() {
    if (!this.tunnelProcess)
      await this.initProcess();
    this.url = await this.tunnelProcess.start();
    return this.url;
  }
  kill() {
    if (this.tunnelProcess) {
      console.log(
        `Killing tunnel ${this.localHost}:${this.localPort} <> ${this.url}`
      );
      this.tunnelProcess.kill();
    }
  }
}

function compareVersion(a, b) {
  const aParts = a.split(".");
  const bParts = b.split(".");
  const len = Math.max(aParts.length, bParts.length);
  const stringToNum = (str) => parseInt(str.match(/\d+/)?.[0] || "0") || 0;
  for (let i = 0; i < len; i++) {
    const aPart = stringToNum(aParts[i]) || 0;
    const bPart = stringToNum(bParts[i]) || 0;
    if (aPart > bPart)
      return 1;
    if (aPart < bPart)
      return -1;
  }
  return 0;
}
function checkNodeVersion() {
  const currentNodeVersion = process.version;
  if (compareVersion(currentNodeVersion, index.MIN_NODE_VERSION) < 0)
    return `You are using Node ${currentNodeVersion}, but GPT-Runner requires Node ${index.MIN_NODE_VERSION}.
Please upgrade your Node version in https://nodejs.org/en/download`;
}
function canUseNodeFetchWithoutCliFlag() {
  const currentNodeVersion = process.version;
  return compareVersion(currentNodeVersion, "18.0.0") > 0;
}
function getRunServerEnv() {
  if (!canUseNodeFetchWithoutCliFlag()) {
    return {
      NODE_OPTIONS: "--experimental-fetch",
      NODE_NO_WARNINGS: "1"
    };
  }
  return {};
}

class FileUtils {
  static async readFile(params) {
    const { filePath, valid = true } = params;
    if (typeof filePath !== "string")
      return "";
    if (valid && !PathUtils.isFile(filePath))
      return "";
    if (!filePath)
      return "";
    return fs.promises.readFile(filePath, { encoding: "utf8" });
  }
  static async writeFile(params) {
    const { filePath, content, overwrite = true, valid = true } = params;
    if (valid) {
      if (!PathUtils.isAccessible(filePath, "W"))
        return;
      if (!PathUtils.isFile(filePath))
        return;
    }
    const dir = PathUtils.getDirPath(filePath);
    if (!PathUtils.isExit(dir))
      await fs.promises.mkdir(dir, { recursive: true });
    if (overwrite)
      await fs.promises.writeFile(filePath, content, { encoding: "utf8" });
    else
      await fs.promises.appendFile(filePath, content, { encoding: "utf8" });
  }
  static async deletePath(fullPath) {
    if (!PathUtils.isAccessible(fullPath, "W"))
      await fs.promises.rm(fullPath, { recursive: true });
  }
  static async ensurePath(params) {
    const { filePath } = params;
    if (!PathUtils.isAccessible(filePath, "W"))
      await fs.promises.mkdir(filePath, { recursive: true });
  }
  static async movePath(params) {
    const { oldPath, newPath } = params;
    if (PathUtils.isAccessible(oldPath, "W"))
      await fs.promises.rename(oldPath, newPath);
  }
  static async travelFiles(params) {
    const { isValidPath, callback } = params;
    const filePath = PathUtils.resolve(params.filePath);
    if (!PathUtils.isAccessible(filePath, "R"))
      return;
    const promises = [];
    if (PathUtils.isDirectory(filePath)) {
      const entries = await fs.promises.readdir(filePath);
      for (const entry of entries) {
        const fullPath = PathUtils.join(filePath, entry);
        if (!PathUtils.isAccessible(filePath, "R"))
          continue;
        const isValid = await isValidPath(fullPath);
        if (isValid)
          promises.push(FileUtils.travelFiles({ filePath: fullPath, isValidPath, callback }));
      }
    } else {
      const result = callback(filePath);
      if (result instanceof Promise)
        promises.push(result);
    }
    await Promise.allSettled(promises);
  }
  static async travelFilesByFilterPattern(params) {
    const { filePath, isValidPath, callback, exts = [], includes = null, excludes = null } = params;
    await FileUtils.travelFiles({
      filePath,
      isValidPath: async (filePath2) => {
        if (exts.length > 0 && PathUtils.isFile(filePath2) && !PathUtils.includeExt(filePath2, exts))
          return false;
        if (!index.createFilterByPattern(includes)(filePath2))
          return false;
        if (index.createFilterByPattern(excludes)(filePath2))
          return false;
        if (!isValidPath(filePath2))
          return false;
        return true;
      },
      callback
    });
  }
}

async function launchEditor(params) {
  return new Promise((resolve, reject) => {
    const { path, lineNum, columnNum = 0, editorName, onError } = params;
    const finalPath = lineNum && columnNum ? `${path}:${lineNum}:${columnNum}` : path;
    launch__default(finalPath, editorName, (error) => {
      if (error) {
        onError?.(error);
        reject(error);
      }
    });
    resolve();
  });
}
async function launchEditorByPathAndContent(params) {
  const { path, matchContent, editorName, onError } = params;
  const content = await FileUtils.readFile({ filePath: path });
  let lineNum = 0;
  let columnNum = 0;
  if (matchContent) {
    const matchContentStartIndex = content.indexOf(matchContent);
    if (matchContentStartIndex !== -1) {
      const beforeMatchContent = content.slice(0, matchContentStartIndex);
      lineNum = beforeMatchContent.split("\n").length;
      columnNum = matchContentStartIndex - beforeMatchContent.lastIndexOf("\n");
    }
  }
  await launchEditor({ path, lineNum, columnNum, editorName, onError });
  return { lineNum, columnNum };
}

async function getStorage(storageName) {
  const cacheFolder = await getGlobalCacheDir("gpt-runner-server");
  const storage = await nodeLocalstorage.kvsLocalStorage({
    name: storageName,
    storeFilePath: cacheFolder,
    version: 1
  });
  return {
    cacheDir: cacheFolder,
    storage
  };
}

function openInBrowser(props) {
  const { url } = props;
  try {
    open__default(url);
  } catch (error) {
    throw new Error(`Server is started at ${url} but failed to open browser. ${error}`);
  }
}
async function getPort(props) {
  const { defaultPort, autoFreePort, excludePorts } = props;
  if (defaultPort) {
    if (!autoFreePort)
      return defaultPort;
    const canUseDefaultPort = await fp__default.isFreePort(defaultPort);
    if (canUseDefaultPort)
      return defaultPort;
  }
  const freePorts = await fp__default.findFreePorts(1, {
    startPort: 3001,
    endPort: 9999,
    isFree: async (port) => {
      if (excludePorts?.includes(port))
        return false;
      return fp__default.isFreePort(port);
    }
  });
  return freePorts[0];
}
function getLocalHostname() {
  return ip__default.address("public", "ipv4");
}

function addNodejsPolyfill() {
  if (!canUseNodeFetchWithoutCliFlag()) {
    console.log("GPT Runner: add polyfill for fetch", process.version);
    globalThis.fetch = undici.fetch;
    globalThis.Headers = undici.Headers;
    globalThis.Request = undici.Request;
    globalThis.Response = undici.Response;
  }
}

async function getDefaultProxyUrl() {
  let proxyUrl = "";
  try {
    const { storage } = await getStorage(index.ServerStorageName.SecretsConfig);
    const proxySecret = await storage.get(index.SecretStorageKey.Proxy);
    proxyUrl = proxySecret?.proxyUrl ?? "";
  } catch (error) {
    console.error("getDefaultProxyUrl error", error);
  }
  if (proxyUrl)
    return proxyUrl;
  ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY"].forEach((key) => {
    if (proxyUrl)
      return;
    const upperKey = key.toUpperCase();
    const lowerKey = key.toLowerCase();
    const upperKeyValue = process.env[upperKey] && process.env[upperKey] !== "undefined" ? process.env[upperKey] || "" : "";
    const lowerKeyValue = process.env[lowerKey] && process.env[lowerKey] !== "undefined" ? process.env[lowerKey] || "" : "";
    return proxyUrl = upperKeyValue || lowerKeyValue || "";
  });
  return proxyUrl;
}

function sendSuccessResponse(res, options) {
  return res.status(options.status || 200).json(index.buildSuccessResponse(options));
}
function sendFailResponse(res, options) {
  return res.status(options.status || 400).json(index.buildFailResponse(options));
}
function verifyParamsByZod(params, schema) {
  index.verifyZod(schema, params);
}

exports.FileUtils = FileUtils;
exports.PathUtils = PathUtils;
exports.Tunnel = Tunnel;
exports.addNodejsPolyfill = addNodejsPolyfill;
exports.canUseNodeFetchWithoutCliFlag = canUseNodeFetchWithoutCliFlag;
exports.checkNodeVersion = checkNodeVersion;
exports.compareVersion = compareVersion;
exports.getDefaultProxyUrl = getDefaultProxyUrl;
exports.getGlobalCacheDir = getGlobalCacheDir;
exports.getLocalHostname = getLocalHostname;
exports.getPort = getPort;
exports.getRunServerEnv = getRunServerEnv;
exports.getStorage = getStorage;
exports.launchEditor = launchEditor;
exports.launchEditorByPathAndContent = launchEditorByPathAndContent;
exports.openInBrowser = openInBrowser;
exports.sendFailResponse = sendFailResponse;
exports.sendSuccessResponse = sendSuccessResponse;
exports.verifyParamsByZod = verifyParamsByZod;