html2apk 0.1.0

package/src/desktop/renderer/renderer.js

@@ -0,0 +1,1074 @@
+"use strict";
+
+const api = window.html2apkDesktop;
+
+const i18n = {
+  pt: {
+    creditTitle: "Creditos iniciais",
+    creditText: "Criado por Dev Caio Multiversando",
+    navHome: "Inicio",
+    navSettings: "Configuracoes",
+    navAppearance: "Aparencia",
+    navBuild: "Build",
+    navLogs: "Logs",
+    navHelp: "Ajuda",
+    theme: "Tema",
+    themeLight: "Claro",
+    themeDark: "Escuro",
+    homeEyebrow: "Comece aqui",
+    homeTitle: "Arraste a pasta do projeto para o html2apk",
+    chooseFolder: "Escolher pasta",
+    dropTitle: "Solte a pasta do seu projeto HTML aqui",
+    dropText: "Depois confirme o build. O APK sera salvo em dist.",
+    indexHint: "A pasta deve conter index.html ou configurar entryFile no app.json",
+    project: "Projeto",
+    configHint: "Configuracao detectada",
+    runDoctor: "Verificar ambiente",
+    confirmBuild: "Confirmar e gerar APK",
+    continueSettings: "Continuar para configuracoes",
+    settingsEyebrow: "Antes de compilar",
+    settingsTitle: "Configuracoes do build",
+    appName: "Nome do app",
+    packageId: "Package ID",
+    appVersion: "Versao do app",
+    mode: "Modo",
+    chooseMode: "Escolha o modo",
+    appIcon: "Icone do app",
+    chooseIcon: "Escolher icone PNG",
+    reviewBuild: "Revisar build",
+    debugBuild: "Debug tecnico",
+    debugBuildText: "Mantem a pasta Cordova temporaria para inspecao.",
+    releaseBuild: "Release",
+    releaseBuildText: "Usa configuracao de assinatura se houver keystore.",
+    appearanceEyebrow: "Preferencias",
+    appearanceTitle: "Idioma e tema",
+    language: "Idioma",
+    languageText: "Escolha como os feedbacks aparecem durante o build.",
+    themeText: "O botao tambem fica na barra lateral para acesso rapido.",
+    toggleTheme: "Alternar tema",
+    buildEyebrow: "Revisao",
+    buildTitle: "Confirme as informacoes e gere o APK",
+    startBuild: "Gerar APK",
+    stepFolder: "Pasta recebida",
+    stepSettings: "Configuracoes completas",
+    stepDoctor: "Ambiente verificado",
+    stepBuild: "APK gerado",
+    apkReady: "APK pronto",
+    openDist: "Abrir dist",
+    showApk: "Mostrar APK",
+    logsEyebrow: "Ao vivo",
+    logsTitle: "Logs do processo",
+    clearLogs: "Limpar logs",
+    helpEyebrow: "Sem misterio",
+    helpTitle: "Doctor, build e dependencias",
+    helpDoctor: "Verifica se Java, Gradle, Cordova e Android SDK estao prontos. Nao gera APK.",
+    helpBuild: "Cria um projeto Cordova temporario, copia seu app web e gera o arquivo APK em dist.",
+    helpDepsTitle: "Dependencias no EXE",
+    helpDeps: "O executavel empacota html2apk, a interface e dependencias Node/Cordova. Se faltarem pacotes Android, ele pede permissao e tenta instalar; JDK/Gradle podem exigir instalacao do sistema.",
+    ready: "Pronto",
+    selected: "Selecionado",
+    missing: "Nao encontrado",
+    detected: "Detectado",
+    notDetected: "Nao detectado",
+    folderReady: "Pasta pronta para build",
+    chooseProjectFirst: "Escolha uma pasta primeiro",
+    doctorRunning: "Verificando ambiente",
+    doctorOk: "Ambiente pronto",
+    doctorFail: "Ambiente incompleto",
+    buildRunning: "Gerando APK",
+    buildOk: "APK gerado com sucesso",
+    buildFail: "Build falhou",
+    droppedFolder: "Pasta recebida",
+    noFolderDrop: "Solte uma pasta do projeto",
+    projectLoaded: "Projeto carregado",
+    logsCleared: "Logs limpos",
+    settingsOk: "Configuracoes completas",
+    settingsMissing: "Complete as configuracoes obrigatorias",
+    requiredFieldsTitle: "Antes de gerar o APK, corrija:",
+    missingProject: "Escolha a pasta do projeto.",
+    missingAppName: "Informe o nome do app.",
+    invalidPackageId: "Informe um Package ID valido, exemplo: com.seuapp.meuapp.",
+    invalidVersion: "Informe a versao no formato 1.0.0.",
+    missingMode: "Escolha o modo do app.",
+    missingIcon: "Escolha o icone do app.",
+    invalidIconType: "Use um icone PNG para evitar falhas no Android.",
+    iconSelected: "Icone selecionado",
+    progressLabel: "Progresso",
+    progressIdle: "Aguardando pasta",
+    progressFolder: "Pasta recebida",
+    progressSettings: "Configuracoes prontas",
+    progressDoctor: "Verificando ambiente",
+    progressBuild: "Gerando APK",
+    progressDone: "APK pronto",
+    progressError: "Algo precisa de atencao",
+    environmentPreparing: "Verificando ambiente antes de avancar",
+    environmentNeedsInstall: "Pacotes Android ausentes. O app vai pedir permissao para instalar.",
+    environmentInstalling: "Instalando pacotes Android",
+    environmentInstallOk: "Pacotes Android instalados",
+    environmentInstallFail: "Nao foi possivel instalar os pacotes Android",
+    environmentCanceled: "Instalacao cancelada",
+    environmentBlocked: "Corrija o ambiente para continuar",
+    bottomLogsTitle: "Logs ao vivo",
+    showLogs: "Mostrar logs",
+    hideLogs: "Ocultar logs",
+    successEyebrow: "Concluido",
+    successTitle: "APK gerado com sucesso",
+    successText: "Seu arquivo Android esta pronto na pasta dist.",
+    newBuild: "Novo build"
+  },
+  en: {
+    creditTitle: "Opening credits",
+    creditText: "Created by Dev Caio Multiversando",
+    navHome: "Home",
+    navSettings: "Settings",
+    navAppearance: "Appearance",
+    navBuild: "Build",
+    navLogs: "Logs",
+    navHelp: "Help",
+    theme: "Theme",
+    themeLight: "Light",
+    themeDark: "Dark",
+    homeEyebrow: "Start here",
+    homeTitle: "Drag your project folder into html2apk",
+    chooseFolder: "Choose folder",
+    dropTitle: "Drop your HTML project folder here",
+    dropText: "Then confirm the build. The APK will be saved in dist.",
+    indexHint: "The folder must contain index.html or configure entryFile in app.json",
+    project: "Project",
+    configHint: "Configuration detected",
+    runDoctor: "Check environment",
+    confirmBuild: "Confirm and build APK",
+    continueSettings: "Continue to settings",
+    settingsEyebrow: "Before compiling",
+    settingsTitle: "Build settings",
+    appName: "App name",
+    packageId: "Package ID",
+    appVersion: "App version",
+    mode: "Mode",
+    chooseMode: "Choose mode",
+    appIcon: "App icon",
+    chooseIcon: "Choose PNG icon",
+    reviewBuild: "Review build",
+    debugBuild: "Technical debug",
+    debugBuildText: "Keeps the temporary Cordova folder for inspection.",
+    releaseBuild: "Release",
+    releaseBuildText: "Uses signing configuration when a keystore exists.",
+    appearanceEyebrow: "Preferences",
+    appearanceTitle: "Language and theme",
+    language: "Language",
+    languageText: "Choose how feedback appears during the build.",
+    themeText: "The button also stays in the sidebar for quick access.",
+    toggleTheme: "Toggle theme",
+    buildEyebrow: "Review",
+    buildTitle: "Confirm the information and build the APK",
+    startBuild: "Build APK",
+    stepFolder: "Folder received",
+    stepSettings: "Settings complete",
+    stepDoctor: "Environment checked",
+    stepBuild: "APK generated",
+    apkReady: "APK ready",
+    openDist: "Open dist",
+    showApk: "Show APK",
+    logsEyebrow: "Live",
+    logsTitle: "Process logs",
+    clearLogs: "Clear logs",
+    helpEyebrow: "Plain and simple",
+    helpTitle: "Doctor, build and dependencies",
+    helpDoctor: "Checks whether Java, Gradle, Cordova and Android SDK are ready. It does not generate an APK.",
+    helpBuild: "Creates a temporary Cordova project, copies your web app and generates the APK in dist.",
+    helpDepsTitle: "Dependencies in the EXE",
+    helpDeps: "The executable bundles html2apk, the interface and Node/Cordova dependencies. If Android packages are missing, it asks permission and tries to install them; JDK/Gradle may still require system installation.",
+    ready: "Ready",
+    selected: "Selected",
+    missing: "Missing",
+    detected: "Detected",
+    notDetected: "Not detected",
+    folderReady: "Folder ready for build",
+    chooseProjectFirst: "Choose a folder first",
+    doctorRunning: "Checking environment",
+    doctorOk: "Environment ready",
+    doctorFail: "Environment incomplete",
+    buildRunning: "Building APK",
+    buildOk: "APK generated successfully",
+    buildFail: "Build failed",
+    droppedFolder: "Folder received",
+    noFolderDrop: "Drop a project folder",
+    projectLoaded: "Project loaded",
+    logsCleared: "Logs cleared",
+    settingsOk: "Settings complete",
+    settingsMissing: "Complete the required settings",
+    requiredFieldsTitle: "Before building the APK, fix:",
+    missingProject: "Choose the project folder.",
+    missingAppName: "Enter the app name.",
+    invalidPackageId: "Enter a valid Package ID, example: com.yourapp.name.",
+    invalidVersion: "Enter the version as 1.0.0.",
+    missingMode: "Choose the app mode.",
+    missingIcon: "Choose the app icon.",
+    invalidIconType: "Use a PNG icon to avoid Android build failures.",
+    iconSelected: "Icon selected",
+    progressLabel: "Progress",
+    progressIdle: "Waiting for folder",
+    progressFolder: "Folder received",
+    progressSettings: "Settings ready",
+    progressDoctor: "Checking environment",
+    progressBuild: "Building APK",
+    progressDone: "APK ready",
+    progressError: "Something needs attention",
+    environmentPreparing: "Checking the environment before continuing",
+    environmentNeedsInstall: "Android packages are missing. The app will ask permission to install them.",
+    environmentInstalling: "Installing Android packages",
+    environmentInstallOk: "Android packages installed",
+    environmentInstallFail: "Could not install Android packages",
+    environmentCanceled: "Installation canceled",
+    environmentBlocked: "Fix the environment to continue",
+    bottomLogsTitle: "Live logs",
+    showLogs: "Show logs",
+    hideLogs: "Hide logs",
+    successEyebrow: "Complete",
+    successTitle: "APK generated successfully",
+    successText: "Your Android file is ready in the dist folder.",
+    newBuild: "New build"
+  }
+};
+
+const animatedBuildLines = [
+  "Preparando projeto / Preparing project",
+  "Conferindo app.json / Reading app.json",
+  "Montando projeto Cordova / Creating Cordova project",
+  "Copiando HTML, CSS e JS / Copying HTML, CSS and JS",
+  "Instalando bridge nativa / Installing native bridge",
+  "Chamando Gradle / Calling Gradle",
+  "Procurando APK final / Finding final APK"
+];
+
+const state = {
+  language: localStorage.getItem("html2apk.language") || null,
+  theme: localStorage.getItem("html2apk.theme") || "light",
+  project: null,
+  doctorOk: false,
+  environmentOk: false,
+  environmentChecking: false,
+  environmentFailed: false,
+  settingsValid: false,
+  buildRunning: false,
+  lastApkPath: null,
+  lastDistPath: null,
+  animationTimer: null,
+  progress: 0,
+  logsVisible: localStorage.getItem("html2apk.logsVisible") === "true"
+};
+
+const elements = {};
+
+function $(id) {
+  return document.getElementById(id);
+}
+
+function text(key) {
+  return i18n[state.language || "pt"][key] || i18n.pt[key] || key;
+}
+
+function collectElements() {
+  [
+    "creditOverlay",
+    "languageOverlay",
+    "dragRegion",
+    "appVersion",
+    "themeToggle",
+    "themeToggleLarge",
+    "themeName",
+    "dropZone",
+    "selectFolderButton",
+    "nextSettingsButton",
+    "projectSummary",
+    "projectName",
+    "projectPath",
+    "configStatus",
+    "entryStatus",
+    "entryPath",
+    "doctorButton",
+    "buildButton",
+    "appNameInput",
+    "packageIdInput",
+    "versionInput",
+    "modeInput",
+    "androidPlatformInput",
+    "iconPathInput",
+    "iconPreview",
+    "selectIconButton",
+    "settingsValidation",
+    "settingsNextButton",
+    "debugInput",
+    "releaseInput",
+    "stepFolderText",
+    "stepSettingsText",
+    "stepDoctorText",
+    "stepBuildText",
+    "progressText",
+    "progressBar",
+    "progressPercent",
+    "reviewGrid",
+    "resultPanel",
+    "apkPath",
+    "openDistButton",
+    "showApkButton",
+    "successApkPath",
+    "successOpenDistButton",
+    "successShowApkButton",
+    "newBuildButton",
+    "logConsole",
+    "bottomLogConsole",
+    "clearLogsButton",
+    "toggleLogsButton",
+    "bottomToggleLogsButton",
+    "bottomClearLogsButton",
+    "minimizeButton",
+    "maximizeButton",
+    "closeButton",
+    "statusDot",
+    "statusText"
+  ].forEach((id) => {
+    elements[id] = $(id);
+  });
+}
+
+function applyTheme() {
+  document.documentElement.dataset.theme = state.theme;
+  localStorage.setItem("html2apk.theme", state.theme);
+  elements.themeName.textContent = state.theme === "dark" ? text("themeDark") : text("themeLight");
+  api.setWindowTheme(state.theme).catch(() => {});
+}
+
+function applyLanguage() {
+  document.documentElement.lang = state.language === "en" ? "en" : "pt-BR";
+  document.querySelectorAll("[data-i18n]").forEach((node) => {
+    node.textContent = text(node.dataset.i18n);
+  });
+  document.querySelectorAll("[data-language-choice]").forEach((button) => {
+    button.classList.toggle("active", button.dataset.languageChoice === state.language);
+  });
+  applyTheme();
+  applyLogBarVisibility();
+  if (state.project) {
+    validateSettings();
+    renderReview();
+  }
+}
+
+function setStatus(kind, message) {
+  elements.statusDot.classList.remove("busy", "error");
+  if (kind === "busy") {
+    elements.statusDot.classList.add("busy");
+  }
+  if (kind === "error") {
+    elements.statusDot.classList.add("error");
+  }
+  elements.statusText.textContent = message;
+}
+
+function setView(viewName) {
+  document.querySelectorAll(".nav-item").forEach((button) => {
+    button.classList.toggle("active", button.dataset.view === viewName);
+  });
+  document.querySelectorAll(".view").forEach((view) => {
+    view.classList.toggle("active", view.id === `view-${viewName}`);
+  });
+}
+
+function appendLogTo(container, line, kind) {
+  if (!container) {
+    return;
+  }
+
+  const node = document.createElement("div");
+  node.className = `log-line ${kind}`;
+  const time = new Date().toLocaleTimeString();
+  node.textContent = `[${time}] ${line}`;
+  container.appendChild(node);
+
+  while (container.children.length > 500) {
+    container.removeChild(container.firstChild);
+  }
+
+  container.scrollTop = container.scrollHeight;
+}
+
+function appendLog(line, kind = "raw") {
+  const lines = String(line || "").split(/\r?\n/).filter(Boolean);
+  for (const item of lines) {
+    appendLogTo(elements.logConsole, item, kind);
+    appendLogTo(elements.bottomLogConsole, item, kind);
+  }
+}
+
+function applyLogBarVisibility() {
+  document.body.classList.toggle("logs-visible", state.logsVisible);
+  localStorage.setItem("html2apk.logsVisible", state.logsVisible ? "true" : "false");
+  const label = text(state.logsVisible ? "hideLogs" : "showLogs");
+
+  [elements.toggleLogsButton, elements.bottomToggleLogsButton].forEach((button) => {
+    if (!button) {
+      return;
+    }
+
+    button.textContent = label;
+    button.setAttribute("aria-expanded", String(state.logsVisible));
+  });
+}
+
+function toggleLogBar() {
+  state.logsVisible = !state.logsVisible;
+  applyLogBarVisibility();
+}
+
+function clearLogs() {
+  elements.logConsole.innerHTML = "";
+  if (elements.bottomLogConsole) {
+    elements.bottomLogConsole.innerHTML = "";
+  }
+  appendLog(text("logsCleared"), "system");
+}
+
+function setStep(step, status, message) {
+  const card = document.querySelector(`[data-step="${step}"]`);
+  if (!card) {
+    return;
+  }
+  card.classList.remove("active", "done", "error");
+  if (status) {
+    card.classList.add(status);
+  }
+  const targets = {
+    folder: "stepFolderText",
+    settings: "stepSettingsText",
+    doctor: "stepDoctorText",
+    build: "stepBuildText"
+  };
+  const target = elements[targets[step]];
+  if (target) {
+    target.textContent = message || "-";
+  }
+}
+
+function setProgress(percent, message, stateClass = "") {
+  const safePercent = Math.max(0, Math.min(100, Math.round(percent)));
+  state.progress = safePercent;
+
+  if (elements.progressBar) {
+    elements.progressBar.style.width = `${safePercent}%`;
+    elements.progressBar.classList.remove("active", "error");
+    if (stateClass) {
+      elements.progressBar.classList.add(stateClass);
+    }
+  }
+
+  if (elements.progressPercent) {
+    elements.progressPercent.textContent = `${safePercent}%`;
+  }
+
+  if (elements.progressText) {
+    elements.progressText.textContent = message;
+  }
+}
+
+function updateActionButtons() {
+  const hasProject = Boolean(state.project);
+  const isBusy = state.environmentChecking || state.buildRunning;
+
+  elements.nextSettingsButton.disabled = !hasProject || isBusy || !state.environmentOk;
+  elements.doctorButton.disabled = !hasProject || isBusy;
+  elements.settingsNextButton.disabled = !hasProject || !state.settingsValid || !state.environmentOk || isBusy;
+  setBuildButtons(hasProject && state.settingsValid && state.environmentOk && !isBusy);
+}
+
+function setBuildButtons(enabled) {
+  elements.buildButton.disabled = !enabled;
+}
+
+function packageSegment(value) {
+  return String(value || "app")
+    .toLowerCase()
+    .replace(/[^a-z0-9_]+/g, "")
+    .replace(/^[^a-z]+/, "") || "app";
+}
+
+function toFileUrl(filePath) {
+  if (!filePath) {
+    return "../../../html2apk.png";
+  }
+  return `file:///${String(filePath).replace(/\\/g, "/").replace(/^\/+/, "")}`;
+}
+
+function isAbsolutePath(filePath) {
+  return /^[a-zA-Z]:[\\/]/.test(String(filePath || "")) || String(filePath || "").startsWith("/");
+}
+
+function iconPreviewPath(iconPath) {
+  if (!iconPath || !state.project) {
+    return "../../../html2apk.png";
+  }
+  if (isAbsolutePath(iconPath)) {
+    return toFileUrl(iconPath);
+  }
+  return toFileUrl(`${state.project.projectRoot}\\${iconPath}`);
+}
+
+function escapeHtml(value) {
+  return String(value || "")
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function populateSettings(config = {}, project = state.project) {
+  const projectName = project ? project.name : "MeuApp";
+  elements.appNameInput.value = config.appName || projectName || "";
+  elements.packageIdInput.value = config.packageId || `com.html2apk.${packageSegment(projectName)}`;
+  elements.versionInput.value = config.version || "1.0.0";
+  elements.modeInput.value = config.mode || "fullscreen";
+  elements.androidPlatformInput.value = config.androidPlatform || "android@15.0.0";
+  elements.iconPathInput.value = config.icon || "";
+  elements.iconPreview.src = iconPreviewPath(config.icon || "");
+  elements.debugInput.checked = Boolean(config.debug);
+  elements.releaseInput.checked = Boolean(config.release);
+}
+
+function validateSettings() {
+  const errors = [];
+  const packagePattern = /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/;
+  const versionPattern = /^\d+\.\d+\.\d+([-.+][0-9A-Za-z.-]+)?$/;
+
+  if (!state.project) {
+    errors.push(text("missingProject"));
+  }
+  if (!elements.appNameInput.value.trim()) {
+    errors.push(text("missingAppName"));
+  }
+  if (!packagePattern.test(elements.packageIdInput.value.trim())) {
+    errors.push(text("invalidPackageId"));
+  }
+  if (!versionPattern.test(elements.versionInput.value.trim())) {
+    errors.push(text("invalidVersion"));
+  }
+  if (!elements.modeInput.value) {
+    errors.push(text("missingMode"));
+  }
+  if (!elements.iconPathInput.value.trim()) {
+    errors.push(text("missingIcon"));
+  } else if (!/\.png$/i.test(elements.iconPathInput.value.trim())) {
+    errors.push(text("invalidIconType"));
+  }
+
+  state.settingsValid = errors.length === 0;
+  setStep("settings", state.settingsValid ? "done" : "active", state.settingsValid ? text("settingsOk") : text("settingsMissing"));
+  updateActionButtons();
+
+  if (state.project && !state.buildRunning && !state.lastApkPath) {
+    if (state.environmentChecking) {
+      setProgress(35, text("progressDoctor"), "active");
+    } else if (!state.environmentOk) {
+      setProgress(state.environmentFailed ? 45 : 25, state.environmentFailed ? text("progressError") : text("progressFolder"), state.environmentFailed ? "error" : "");
+    } else {
+      setProgress(state.settingsValid ? 70 : 50, state.settingsValid ? text("progressSettings") : text("settingsMissing"));
+    }
+  }
+
+  if (!errors.length) {
+    elements.settingsValidation.classList.add("hidden");
+    elements.settingsValidation.innerHTML = "";
+    return true;
+  }
+
+  elements.settingsValidation.classList.remove("hidden");
+  elements.settingsValidation.innerHTML = `<p>${text("requiredFieldsTitle")}</p><ul>${errors.map((error) => `<li>${error}</li>`).join("")}</ul>`;
+  return false;
+}
+
+function renderReview() {
+  if (!state.project) {
+    elements.reviewGrid.innerHTML = "";
+    return;
+  }
+
+  const items = [
+    [text("project"), state.project.projectRoot],
+    [text("appName"), elements.appNameInput.value.trim()],
+    [text("packageId"), elements.packageIdInput.value.trim()],
+    [text("appVersion"), elements.versionInput.value.trim()],
+    [text("mode"), elements.modeInput.value],
+    [text("appIcon"), elements.iconPathInput.value.trim()]
+  ];
+
+  elements.reviewGrid.innerHTML = items.map(([label, value]) => `
+    <article class="review-item">
+      <span>${escapeHtml(label)}</span>
+      <strong title="${escapeHtml(value)}">${escapeHtml(value)}</strong>
+    </article>
+  `).join("");
+}
+
+function goToReview() {
+  if (!state.environmentOk) {
+    setView("build");
+    setStatus(state.environmentChecking ? "busy" : "error", state.environmentChecking ? text("doctorRunning") : text("environmentBlocked"));
+    setProgress(state.environmentChecking ? 35 : 45, state.environmentChecking ? text("progressDoctor") : text("progressError"), state.environmentChecking ? "active" : "error");
+    return false;
+  }
+
+  if (!validateSettings()) {
+    setView("settings");
+    setStatus("error", text("settingsMissing"));
+    return false;
+  }
+
+  renderReview();
+  setView("build");
+  setStatus("ready", text("settingsOk"));
+  return true;
+}
+
+function hasAndroidInstallableFailure(response) {
+  const checks = response && response.report && Array.isArray(response.report.checks)
+    ? response.report.checks
+    : [];
+
+  return checks.some((check) => {
+    const name = String(check.name || "");
+    return !check.ok && (
+      name.includes("ANDROID_HOME") ||
+      name.includes("Android platform-tools") ||
+      name.includes("Android cmdline-tools") ||
+      name.includes("Android sdkmanager") ||
+      name.includes("Android build-tools") ||
+      name.includes("Android platform ")
+    );
+  });
+}
+
+function markEnvironmentReady() {
+  state.doctorOk = true;
+  state.environmentOk = true;
+  state.environmentFailed = false;
+  setStep("doctor", "done", text("doctorOk"));
+  setStatus("ready", text("doctorOk"));
+  setProgress(state.settingsValid ? 70 : 50, state.settingsValid ? text("progressSettings") : text("doctorOk"));
+}
+
+function markEnvironmentBlocked(message = text("doctorFail")) {
+  state.doctorOk = false;
+  state.environmentOk = false;
+  state.environmentFailed = true;
+  setStep("doctor", "error", message);
+  setStatus("error", message);
+  setProgress(45, text("progressError"), "error");
+}
+
+async function installAndroidRequirements() {
+  setStatus("busy", text("environmentInstalling"));
+  setStep("doctor", "active", text("environmentInstalling"));
+  setProgress(45, text("environmentInstalling"), "active");
+  appendLog(text("environmentNeedsInstall"), "system");
+
+  try {
+    const result = await api.installAndroidRequirements();
+    if (result && result.canceled) {
+      appendLog(text("environmentCanceled"), "system");
+      markEnvironmentBlocked(text("environmentCanceled"));
+      return false;
+    }
+
+    appendLog(result && result.message ? result.message : (result && result.ok ? text("environmentInstallOk") : text("environmentInstallFail")), result && result.ok ? "success" : "error");
+    return Boolean(result && result.ok);
+  } catch (error) {
+    appendLog(error.message, "error");
+    markEnvironmentBlocked(text("environmentInstallFail"));
+    return false;
+  }
+}
+
+async function verifyEnvironment({ allowInstall = true, requireSettings = false } = {}) {
+  if (!state.project) {
+    setStatus("error", text("chooseProjectFirst"));
+    return false;
+  }
+  if (requireSettings && !validateSettings()) {
+    setView("settings");
+    setStatus("error", text("settingsMissing"));
+    return false;
+  }
+
+  state.environmentChecking = true;
+  state.environmentOk = false;
+  state.environmentFailed = false;
+  updateActionButtons();
+  setView("build");
+  setStatus("busy", text("doctorRunning"));
+  setStep("doctor", "active", text("doctorRunning"));
+  setProgress(35, text("progressDoctor"), "active");
+  appendLog(text("environmentPreparing"), "animated");
+
+  try {
+    const firstResponse = await api.runDoctor(state.project.projectRoot);
+    appendLog(firstResponse.text, firstResponse.ok ? "success" : "error");
+
+    if (firstResponse.ok) {
+      markEnvironmentReady();
+      return true;
+    }
+
+    if (allowInstall && hasAndroidInstallableFailure(firstResponse)) {
+      const installed = await installAndroidRequirements();
+      if (!installed) {
+        return false;
+      }
+
+      setStatus("busy", text("doctorRunning"));
+      setStep("doctor", "active", text("doctorRunning"));
+      setProgress(55, text("progressDoctor"), "active");
+      appendLog(text("environmentPreparing"), "animated");
+
+      const retryResponse = await api.runDoctor(state.project.projectRoot);
+      appendLog(retryResponse.text, retryResponse.ok ? "success" : "error");
+      if (retryResponse.ok) {
+        markEnvironmentReady();
+        return true;
+      }
+    }
+
+    markEnvironmentBlocked(text("doctorFail"));
+    return false;
+  } catch (error) {
+    appendLog(error.message, "error");
+    markEnvironmentBlocked(error.message);
+    return false;
+  } finally {
+    state.environmentChecking = false;
+    validateSettings();
+    updateActionButtons();
+  }
+}
+
+async function ensureEnvironmentBeforeSettings() {
+  const ready = state.environmentOk || await verifyEnvironment({ allowInstall: true, requireSettings: false });
+  if (ready) {
+    validateSettings();
+    setView("settings");
+  } else {
+    setView("build");
+  }
+  return ready;
+}
+
+async function summarizeProject(project) {
+  state.project = project;
+  state.doctorOk = false;
+  state.environmentOk = false;
+  state.environmentChecking = false;
+  state.environmentFailed = false;
+  state.settingsValid = false;
+  state.lastApkPath = null;
+  state.lastDistPath = project.distPath;
+
+  elements.projectSummary.classList.remove("hidden");
+  elements.projectName.textContent = project.name;
+  elements.projectPath.textContent = project.projectRoot;
+  elements.configStatus.textContent = project.hasAppJson || project.hasConfigJson ? text("detected") : text("notDetected");
+  elements.entryStatus.textContent = project.hasEntryFile ? text("detected") : text("missing");
+  elements.entryPath.textContent = project.entryPath;
+  elements.nextSettingsButton.disabled = false;
+  elements.doctorButton.disabled = true;
+  setBuildButtons(false);
+  populateSettings(project.config || {}, project);
+  setStep("folder", project.hasEntryFile ? "done" : "active", project.hasEntryFile ? text("folderReady") : text("missing"));
+  setStep("settings", "active", text("settingsMissing"));
+  setStep("doctor", null, "-");
+  setStep("build", null, "-");
+  elements.resultPanel.classList.add("hidden");
+  setStatus("ready", text("projectLoaded"));
+  appendLog(`${text("droppedFolder")}: ${project.projectRoot}`, "system");
+  validateSettings();
+  setProgress(project.hasEntryFile ? 25 : 15, project.hasEntryFile ? text("progressFolder") : text("missing"), project.hasEntryFile ? "" : "error");
+  await ensureEnvironmentBeforeSettings();
+}
+
+async function loadProject(projectRoot) {
+  try {
+    const project = await api.inspectProject(projectRoot);
+    await summarizeProject(project);
+  } catch (error) {
+    setStatus("error", error.message);
+    appendLog(error.message, "error");
+  }
+}
+
+async function chooseFolder() {
+  try {
+    const project = await api.selectFolder();
+    if (project) {
+      await summarizeProject(project);
+    }
+  } catch (error) {
+    setStatus("error", error.message);
+    appendLog(error.message, "error");
+  }
+}
+
+async function runDoctorOnly() {
+  if (!state.project) {
+    setStatus("error", text("chooseProjectFirst"));
+    return false;
+  }
+
+  return verifyEnvironment({ allowInstall: true, requireSettings: false });
+}
+
+function buildOptions() {
+  return {
+    projectRoot: state.project.projectRoot,
+    appName: elements.appNameInput.value.trim(),
+    packageId: elements.packageIdInput.value.trim(),
+    version: elements.versionInput.value.trim(),
+    mode: elements.modeInput.value,
+    icon: elements.iconPathInput.value.trim(),
+    androidPlatform: elements.androidPlatformInput.value.trim(),
+    debug: elements.debugInput.checked,
+    release: elements.releaseInput.checked
+  };
+}
+
+function startAnimatedLogs() {
+  stopAnimatedLogs();
+  let index = 0;
+  state.animationTimer = setInterval(() => {
+    appendLog(animatedBuildLines[index % animatedBuildLines.length], "animated");
+    index += 1;
+  }, 1650);
+}
+
+function stopAnimatedLogs() {
+  if (state.animationTimer) {
+    clearInterval(state.animationTimer);
+    state.animationTimer = null;
+  }
+}
+
+async function runBuildFlow() {
+  if (!state.project || state.buildRunning) {
+    setStatus("error", state.project ? text("buildRunning") : text("chooseProjectFirst"));
+    return;
+  }
+  if (!goToReview()) {
+    return;
+  }
+
+  state.buildRunning = true;
+  updateActionButtons();
+  elements.resultPanel.classList.add("hidden");
+  setView("build");
+  setStep("folder", "done", text("folderReady"));
+
+  const doctorOk = await runDoctorOnly();
+  if (!doctorOk) {
+    state.buildRunning = false;
+    updateActionButtons();
+    return;
+  }
+
+  setStatus("busy", text("buildRunning"));
+  setStep("build", "active", text("buildRunning"));
+  setProgress(90, text("progressBuild"), "active");
+  startAnimatedLogs();
+
+  try {
+    const response = await api.runBuild(buildOptions());
+    stopAnimatedLogs();
+    if (!response.ok) {
+      setStep("build", "error", text("buildFail"));
+      setStatus("error", text("buildFail"));
+      setProgress(90, text("progressError"), "error");
+      appendLog(response.message || text("buildFail"), "error");
+      if (response.buildDir) {
+        appendLog(`Build directory kept: ${response.buildDir}`, "system");
+      }
+      return;
+    }
+
+    const result = response.result;
+    state.lastApkPath = result.apkPath;
+    state.lastDistPath = state.project.distPath;
+    elements.apkPath.textContent = result.apkPath;
+    elements.successApkPath.textContent = result.apkPath;
+    elements.resultPanel.classList.remove("hidden");
+    setStep("build", "done", text("buildOk"));
+    setStatus("ready", text("buildOk"));
+    setProgress(100, text("progressDone"));
+    appendLog(`${text("buildOk")}: ${result.apkPath}`, "success");
+    setView("success");
+  } catch (error) {
+    stopAnimatedLogs();
+    setStep("build", "error", text("buildFail"));
+    setStatus("error", error.message);
+    setProgress(90, text("progressError"), "error");
+    appendLog(error.message, "error");
+  } finally {
+    state.buildRunning = false;
+    updateActionButtons();
+  }
+}
+
+function toggleTheme() {
+  state.theme = state.theme === "dark" ? "light" : "dark";
+  applyTheme();
+}
+
+function chooseLanguage(language) {
+  state.language = language;
+  localStorage.setItem("html2apk.language", language);
+  applyLanguage();
+  hideOverlay(elements.languageOverlay);
+}
+
+function hideOverlay(overlay) {
+  overlay.classList.add("hiding");
+  setTimeout(() => overlay.classList.add("hidden"), 360);
+}
+
+function finishBoot() {
+  hideOverlay(elements.creditOverlay);
+  if (!state.language) {
+    setTimeout(() => elements.languageOverlay.classList.remove("hidden"), 380);
+  }
+}
+
+function bindEvents() {
+  document.querySelectorAll(".nav-item[data-view]").forEach((button) => {
+    button.addEventListener("click", async () => {
+      if (button.dataset.view === "settings" && state.project && !state.environmentOk) {
+        await ensureEnvironmentBeforeSettings();
+        return;
+      }
+      if (button.dataset.view === "build" && !goToReview()) {
+        return;
+      }
+      setView(button.dataset.view);
+    });
+  });
+
+  document.querySelectorAll("[data-language-choice]").forEach((button) => {
+    button.addEventListener("click", () => chooseLanguage(button.dataset.languageChoice));
+  });
+
+  elements.themeToggle.addEventListener("click", toggleTheme);
+  elements.themeToggleLarge.addEventListener("click", toggleTheme);
+  elements.selectFolderButton.addEventListener("click", chooseFolder);
+  elements.nextSettingsButton.addEventListener("click", ensureEnvironmentBeforeSettings);
+  elements.settingsNextButton.addEventListener("click", goToReview);
+  elements.doctorButton.addEventListener("click", runDoctorOnly);
+  elements.buildButton.addEventListener("click", runBuildFlow);
+  elements.clearLogsButton.addEventListener("click", clearLogs);
+  elements.toggleLogsButton.addEventListener("click", toggleLogBar);
+  elements.bottomToggleLogsButton.addEventListener("click", toggleLogBar);
+  elements.bottomClearLogsButton.addEventListener("click", clearLogs);
+  elements.selectIconButton.addEventListener("click", async () => {
+    const iconPath = await api.selectIcon();
+    if (!iconPath) {
+      return;
+    }
+    elements.iconPathInput.value = iconPath;
+    elements.iconPreview.src = iconPreviewPath(iconPath);
+    appendLog(`${text("iconSelected")}: ${iconPath}`, "system");
+    validateSettings();
+  });
+  [
+    elements.appNameInput,
+    elements.packageIdInput,
+    elements.versionInput,
+    elements.modeInput,
+    elements.androidPlatformInput,
+    elements.debugInput,
+    elements.releaseInput
+  ].forEach((input) => {
+    input.addEventListener("input", validateSettings);
+    input.addEventListener("change", validateSettings);
+  });
+  elements.dragRegion.addEventListener("dblclick", () => api.toggleMaximizeWindow());
+  elements.minimizeButton.addEventListener("click", () => api.minimizeWindow());
+  elements.maximizeButton.addEventListener("click", () => api.toggleMaximizeWindow());
+  elements.closeButton.addEventListener("click", () => api.closeWindow());
+  elements.openDistButton.addEventListener("click", () => {
+    if (state.lastDistPath) {
+      api.openPath(state.lastDistPath);
+    }
+  });
+  elements.showApkButton.addEventListener("click", () => {
+    if (state.lastApkPath) {
+      api.showItem(state.lastApkPath);
+    }
+  });
+  elements.successOpenDistButton.addEventListener("click", () => {
+    if (state.lastDistPath) {
+      api.openPath(state.lastDistPath);
+    }
+  });
+  elements.successShowApkButton.addEventListener("click", () => {
+    if (state.lastApkPath) {
+      api.showItem(state.lastApkPath);
+    }
+  });
+  elements.newBuildButton.addEventListener("click", () => {
+    state.lastApkPath = null;
+    elements.resultPanel.classList.add("hidden");
+    goToReview();
+  });
+
+  elements.dropZone.addEventListener("dragover", (event) => {
+    event.preventDefault();
+    elements.dropZone.classList.add("dragging");
+  });
+  elements.dropZone.addEventListener("dragleave", () => {
+    elements.dropZone.classList.remove("dragging");
+  });
+  elements.dropZone.addEventListener("drop", async (event) => {
+    event.preventDefault();
+    elements.dropZone.classList.remove("dragging");
+    const file = event.dataTransfer.files && event.dataTransfer.files[0];
+    if (!file) {
+      setStatus("error", text("noFolderDrop"));
+      return;
+    }
+    const projectRoot = api.pathForFile(file);
+    await loadProject(projectRoot);
+  });
+
+  api.onBuildLog((payload) => {
+    appendLog(payload.line, payload.kind || "raw");
+  });
+
+  api.onInstallLog((payload) => {
+    appendLog(payload.line, payload.kind || "raw");
+  });
+}
+
+async function init() {
+  collectElements();
+  bindEvents();
+  applyLanguage();
+  applyTheme();
+  applyLogBarVisibility();
+  setStatus("ready", text("ready"));
+  setProgress(0, text("progressIdle"));
+  updateActionButtons();
+  appendLog("html2apk desktop ready / interface pronta", "system");
+
+  try {
+    const info = await api.appInfo();
+    elements.appVersion.textContent = `v${info.version}`;
+  } catch {
+    elements.appVersion.textContent = "v0.1.0";
+  }
+
+  setTimeout(finishBoot, 1800);
+}
+
+document.addEventListener("DOMContentLoaded", init);