https-preview.js

"use strict";

const childProcess = require("child_process");
const fs = require("fs");
const http = require("http");
const https = require("https");
const path = require("path");

const root = __dirname;
const port = Number(process.argv[2] || 4190);
const origin = "http://127.0.0.1:" + port;
const toolsDir = path.join(root, "tools");
const cloudflared = path.join(toolsDir, "cloudflared.exe");
const logDir = path.join(root, "debug-sheets");
const stamp = timestamp();
const logFile = path.join(logDir, "cloudflared-https-" + stamp + ".log");
const urlFile = path.join(logDir, "cloudflared-https-url.txt");
const pidFile = path.join(logDir, "cloudflared-https.pid");

function timestamp() {
  const d = new Date();
  function pad(n) {
    return String(n).padStart(2, "0");
  }
  return String(d.getFullYear()) + pad(d.getMonth() + 1) + pad(d.getDate()) + "-" + pad(d.getHours()) + pad(d.getMinutes()) + pad(d.getSeconds());
}

function sleep(ms) {
  return new Promise(function (resolve) {
    setTimeout(resolve, ms);
  });
}

function ensureDir(dir) {
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
  }
}

function ensureCloudflared() {
  ensureDir(toolsDir);
  if (fs.existsSync(cloudflared)) return;
  const downloadUrl = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe";
  childProcess.execFileSync("curl.exe", ["-L", "--fail", "-o", cloudflared, downloadUrl], { stdio: "inherit" });
  if (!fs.existsSync(cloudflared)) {
    throw new Error("cloudflared download failed");
  }
}

function request(url, timeoutMs) {
  return new Promise(function (resolve, reject) {
    const client = url.indexOf("https://") === 0 ? https : http;
    const req = client.get(url, function (res) {
      res.resume();
      res.on("end", function () {
        if (res.statusCode >= 200 && res.statusCode < 400) {
          resolve(res.statusCode);
        } else {
          reject(new Error("HTTP " + res.statusCode));
        }
      });
    });
    req.setTimeout(timeoutMs, function () {
      req.destroy(new Error("timeout"));
    });
    req.on("error", reject);
  });
}

async function ensureLocalServer() {
  try {
    await request(origin + "/?health=https-preview", 5000);
    return null;
  } catch (error) {
    const server = childProcess.spawn("python", ["-m", "http.server", String(port), "--bind", "127.0.0.1"], {
      cwd: root,
      detached: true,
      stdio: "ignore"
    });
    server.unref();
    await sleep(1200);
    await request(origin + "/?health=https-preview", 8000);
    return server.pid;
  }
}

function startTunnel() {
  const tunnel = childProcess.spawn(cloudflared, [
    "--logfile", logFile,
    "--loglevel", "info",
    "tunnel",
    "--url", origin,
    "--no-autoupdate",
    "--protocol", "http2"
  ], {
    cwd: root,
    detached: true,
    stdio: "ignore"
  });
  tunnel.unref();
  return tunnel.pid;
}

function stopExistingTunnels() {
  if (process.platform !== "win32") return;
  try {
    const safeRoot = root.replace(/'/g, "''");
    const command = "$root = '" + safeRoot + "'; " +
      "Get-CimInstance Win32_Process | " +
      "Where-Object { $_.Name -eq 'cloudflared.exe' -and $_.CommandLine -match [regex]::Escape($root) } | " +
      "ForEach-Object { Stop-Process -Id $_.ProcessId -Force }";
    childProcess.execFileSync("powershell.exe", ["-NoProfile", "-Command", command], { stdio: "ignore" });
  } catch (error) {
  }
}

function readTunnelUrl() {
  if (!fs.existsSync(logFile)) return "";
  const text = fs.readFileSync(logFile, "utf8");
  const match = text.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
  return match ? match[0] : "";
}

async function waitForTunnelUrl() {
  let i;
  let url = "";
  for (i = 0; i < 60; i += 1) {
    await sleep(1000);
    url = readTunnelUrl();
    if (url) return url;
  }
  throw new Error("Cloudflare HTTPS URL was not created. Check " + logFile);
}

async function waitForPublicUrl(url) {
  let i;
  let lastError = "";
  for (i = 0; i < 45; i += 1) {
    try {
      return await request(url, 20000);
    } catch (error) {
      lastError = error.message;
      await sleep(2000);
    }
  }
  throw new Error("HTTPS URL was created but is not reachable yet: " + url + " Last error: " + lastError);
}

function openBrowser(url) {
  try {
    const proc = childProcess.spawn("cmd.exe", ["/c", "start", "", url], {
      detached: true,
      stdio: "ignore"
    });
    proc.unref();
  } catch (error) {
  }
}

async function main() {
  ensureDir(logDir);
  ensureCloudflared();
  const serverPid = await ensureLocalServer();
  stopExistingTunnels();
  const tunnelPid = startTunnel();
  const publicBase = await waitForTunnelUrl();
  const previewUrl = publicBase + "/?refresh=public-https-v33";
  const status = await waitForPublicUrl(previewUrl);

  fs.writeFileSync(urlFile, previewUrl);
  fs.writeFileSync(pidFile, String(tunnelPid));

  let message = "\nFlowerMoji HTTPS preview is running.\n";
  if (serverPid) message += "Local server PID: " + serverPid + "\n";
  message += "Cloudflare tunnel PID: " + tunnelPid + "\n\n";
  message += "Open this HTTPS URL on your phone:\n";
  message += previewUrl + "\n\n";
  message += "HTTPS check: HTTP " + status + "\n\n";
  message += "This is a temporary preview URL. It stays alive while this PC and the tunnel process are running.\n";
  process.stdout.write(message);

  openBrowser(previewUrl);
}

main().catch(function (error) {
  console.error(error.message);
  process.exit(1);
});