html2apk 0.1.0

package/src/core/validation.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const fs = require("fs/promises");
+const path = require("path");
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function assertInside(parent, child, label) {
+  const relative = path.relative(parent, child);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`${label} must stay inside the project root.`);
+  }
+}
+
+async function validateEntryFile(projectRoot, options) {
+  const webRoot = path.resolve(projectRoot, options.webRoot || ".");
+  assertInside(projectRoot, webRoot, "webRoot");
+
+  const entryFile = options.entryFile || "index.html";
+  const entryPath = path.resolve(webRoot, entryFile);
+  assertInside(webRoot, entryPath, "entryFile");
+
+  if (!(await exists(entryPath))) {
+    throw new Error(`Entry file not found: ${path.relative(projectRoot, entryPath)}`);
+  }
+
+  return {
+    webRoot,
+    entryPath
+  };
+}
+
+function validatePackageId(packageId) {
+  const pattern = /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/;
+  if (!pattern.test(packageId)) {
+    throw new Error(`Invalid packageId "${packageId}". Example: com.company.app`);
+  }
+}
+
+function validateRequiredOptions(options) {
+  if (!options.appName) {
+    throw new Error("appName is required.");
+  }
+  validatePackageId(options.packageId);
+}
+
+module.exports = {
+  validateEntryFile,
+  validateRequiredOptions,
+  assertInside
+};

package/src/desktop/main.js

@@ -0,0 +1,522 @@
+"use strict";
+
+const fs = require("fs/promises");
+const path = require("path");
+const { spawn } = require("child_process");
+const { app, BrowserWindow, dialog, ipcMain, screen, shell } = require("electron");
+const { buildApk } = require("../core/build-apk");
+const {
+  REQUIRED_ANDROID_BUILD_TOOLS,
+  REQUIRED_ANDROID_PLATFORM,
+  getRuntimeEnvironment
+} = require("../runtime-manager");
+const { runDoctor, formatDoctorReport } = require("../runtime-manager/doctor");
+
+let mainWindow = null;
+const smokeTest = process.env.HTML2APK_DESKTOP_SMOKE === "1";
+const WINDOW_BACKGROUNDS = {
+  light: "#f7fbff",
+  dark: "#10141b"
+};
+
+app.commandLine.appendSwitch("disable-crash-reporter");
+
+function rootPath(...parts) {
+  return path.resolve(__dirname, "..", "..", ...parts);
+}
+
+function iconPath() {
+  return rootPath("html2apk.png");
+}
+
+function animateWindowIn(window) {
+  let opacity = 0;
+  window.setOpacity(opacity);
+  window.show();
+  window.focus();
+
+  const timer = setInterval(() => {
+    opacity = Math.min(1, opacity + 0.08);
+    window.setOpacity(opacity);
+    if (opacity >= 1) {
+      clearInterval(timer);
+    }
+  }, 16);
+}
+
+function createWindow() {
+  const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().workAreaSize;
+  const width = Math.min(1280, Math.max(860, Math.floor(screenWidth * 0.92)));
+  const height = Math.min(820, Math.max(620, Math.floor(screenHeight * 0.9)));
+
+  mainWindow = new BrowserWindow({
+    width,
+    height,
+    minWidth: Math.min(860, width),
+    minHeight: Math.min(620, height),
+    center: true,
+    show: false,
+    frame: false,
+    title: "html2apk",
+    icon: iconPath(),
+    backgroundColor: WINDOW_BACKGROUNDS.light,
+    webPreferences: {
+      preload: path.join(__dirname, "preload.js"),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false
+    }
+  });
+
+  mainWindow.loadFile(path.join(__dirname, "renderer", "index.html"));
+  if (smokeTest) {
+    mainWindow.webContents.once("did-finish-load", () => {
+      setTimeout(() => app.quit(), 500);
+    });
+  }
+  mainWindow.once("ready-to-show", () => animateWindowIn(mainWindow));
+}
+
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJsonIfExists(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+async function inspectProject(projectRoot) {
+  if (!projectRoot) {
+    throw new Error("Project folder is required.");
+  }
+
+  const stat = await fs.stat(projectRoot);
+  if (!stat.isDirectory()) {
+    throw new Error("Please choose a folder, not a file.");
+  }
+
+  const appJsonPath = path.join(projectRoot, "app.json");
+  const configJsonPath = path.join(projectRoot, "config.json");
+  const indexPath = path.join(projectRoot, "index.html");
+  const appConfig = await readJsonIfExists(appJsonPath);
+  const fallbackConfig = appConfig ? null : await readJsonIfExists(configJsonPath);
+  const config = appConfig || fallbackConfig || {};
+  const webRoot = path.resolve(projectRoot, config.webRoot || ".");
+  const entryPath = path.resolve(webRoot, config.entryFile || "index.html");
+
+  return {
+    projectRoot,
+    name: path.basename(projectRoot),
+    hasAppJson: await pathExists(appJsonPath),
+    hasConfigJson: await pathExists(configJsonPath),
+    hasRootIndex: await pathExists(indexPath),
+    hasEntryFile: await pathExists(entryPath),
+    entryPath,
+    config,
+    distPath: path.join(projectRoot, "dist")
+  };
+}
+
+function cleanBuildOptions(options = {}) {
+  const output = {
+    projectRoot: options.projectRoot,
+    debug: Boolean(options.debug),
+    release: Boolean(options.release)
+  };
+
+  for (const key of ["mode", "appName", "packageId", "version", "icon", "androidPlatform"]) {
+    if (options[key]) {
+      output[key] = options[key];
+    }
+  }
+
+  return output;
+}
+
+function quoteForCmd(value) {
+  const text = String(value);
+  if (!text.length) {
+    return "\"\"";
+  }
+
+  if (/^[a-zA-Z0-9_@./:\\=+\-;]+$/.test(text)) {
+    return text;
+  }
+
+  return `"${text.replace(/(["^&|<>])/g, "^$1")}"`;
+}
+
+function createSpawnSpec(command, args) {
+  const needsCmd = process.platform === "win32" && /\.(cmd|bat)$/i.test(command);
+  if (!needsCmd) {
+    return { command, args };
+  }
+
+  return {
+    command: "cmd.exe",
+    args: ["/d", "/s", "/c", [quoteForCmd(command), ...args.map(quoteForCmd)].join(" ")]
+  };
+}
+
+function sdkManagerPath(runtime) {
+  if (!runtime.cmdlineTools) {
+    return null;
+  }
+
+  return path.join(runtime.cmdlineTools, process.platform === "win32" ? "sdkmanager.bat" : "sdkmanager");
+}
+
+function androidPackageArgs() {
+  return [
+    "platform-tools",
+    `platforms;${REQUIRED_ANDROID_PLATFORM}`,
+    `build-tools;${REQUIRED_ANDROID_BUILD_TOOLS}`,
+    "cmdline-tools;latest"
+  ];
+}
+
+function sendInstallLog(sender, line, kind = "raw") {
+  sender.send("install:log", {
+    line,
+    kind,
+    time: new Date().toISOString()
+  });
+}
+
+async function findAndroidCli() {
+  if (process.platform !== "win32") {
+    return null;
+  }
+
+  const candidates = [
+    process.env.LOCALAPPDATA
+      ? path.join(
+        process.env.LOCALAPPDATA,
+        "Microsoft",
+        "WinGet",
+        "Packages",
+        "Google.AndroidCLI_Microsoft.Winget.Source_8wekyb3d8bbwe",
+        "android.exe"
+      )
+      : null,
+    "android.exe"
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    if (candidate === "android.exe" || await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function runInstallCommand(sender, command, args, options = {}) {
+  const pretty = `${command} ${args.join(" ")}`.trim();
+  const spawnSpec = createSpawnSpec(command, args);
+  const env = options.env || process.env;
+
+  sendInstallLog(sender, `$ ${pretty}`, "system");
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(spawnSpec.command, spawnSpec.args, {
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: false,
+      windowsHide: true
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    function acceptLicenseIfPrompted(text) {
+      if (!options.acceptLicenses || !child.stdin.writable) {
+        return;
+      }
+
+      if (/(accept|license|licen[cç]a|y\/n|y\/N|\[y\/n\]|\(y\/N\))/i.test(text)) {
+        child.stdin.write("y\n");
+      }
+    }
+
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      sendInstallLog(sender, text);
+      acceptLicenseIfPrompted(text);
+    });
+
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      sendInstallLog(sender, text, "error");
+      acceptLicenseIfPrompted(text);
+    });
+
+    child.on("error", (error) => {
+      reject(new Error(`Failed to run "${pretty}": ${error.message}`));
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({ code, stdout, stderr });
+        return;
+      }
+
+      const error = new Error(`Command failed (${code}): ${pretty}`);
+      error.code = code;
+      error.stdout = stdout;
+      error.stderr = stderr;
+      reject(error);
+    });
+  });
+}
+
+async function askAndroidInstallPermission() {
+  const result = await dialog.showMessageBox(mainWindow, {
+    type: "question",
+    buttons: ["Instalar", "Cancelar"],
+    defaultId: 0,
+    cancelId: 1,
+    title: "html2apk",
+    message: "Instalar pacotes Android necessarios?",
+    detail: [
+      "O html2apk precisa do Android SDK com platform-tools, Android Platform 36, Build Tools 36.0.0 e command line tools.",
+      "Ao continuar, o instalador pode baixar pacotes e aceitar as licencas Android necessarias para o build."
+    ].join("\n\n")
+  });
+
+  return result.response === 0;
+}
+
+async function installWithSdkManager(sender, sdkManager, runtime) {
+  const args = androidPackageArgs();
+  await runInstallCommand(sender, sdkManager, ["--licenses"], {
+    env: runtime.env,
+    acceptLicenses: true
+  }).catch((error) => {
+    sendInstallLog(sender, error.message, "error");
+  });
+
+  await runInstallCommand(sender, sdkManager, args, {
+    env: runtime.env,
+    acceptLicenses: true
+  });
+}
+
+async function installWithWingetAndroidCli(sender) {
+  if (process.platform !== "win32") {
+    throw new Error("Automatic Android CLI installation is only available on Windows in this desktop app.");
+  }
+
+  try {
+    await runInstallCommand(sender, "winget", [
+      "install",
+      "--id",
+      "Google.AndroidCLI",
+      "-e",
+      "--accept-package-agreements",
+      "--accept-source-agreements"
+    ]);
+  } catch (error) {
+    sendInstallLog(sender, error.message, "error");
+  }
+
+  const androidCli = await findAndroidCli();
+  if (!androidCli) {
+    throw new Error("Android CLI was not found after the Winget step.");
+  }
+
+  await runInstallCommand(sender, androidCli, ["sdk", "install", ...androidPackageArgs()], {
+    acceptLicenses: true
+  });
+}
+
+app.whenReady().then(() => {
+  createWindow();
+
+  app.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) {
+      createWindow();
+    }
+  });
+});
+
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});
+
+ipcMain.handle("app:info", () => ({
+  name: "html2apk",
+  version: app.getVersion(),
+  credit: "Dev Caio Multiversando",
+  iconPath: iconPath()
+}));
+
+ipcMain.handle("window:minimize", () => {
+  BrowserWindow.getFocusedWindow()?.minimize();
+});
+
+ipcMain.handle("window:toggle-maximize", () => {
+  const window = BrowserWindow.getFocusedWindow();
+  if (!window) {
+    return false;
+  }
+
+  if (window.isMaximized()) {
+    window.unmaximize();
+    return false;
+  }
+
+  window.maximize();
+  return true;
+});
+
+ipcMain.handle("window:close", () => {
+  BrowserWindow.getFocusedWindow()?.close();
+});
+
+ipcMain.handle("window:set-theme", (_event, theme) => {
+  const nextTheme = theme === "dark" ? "dark" : "light";
+  BrowserWindow.getFocusedWindow()?.setBackgroundColor(WINDOW_BACKGROUNDS[nextTheme]);
+  return nextTheme;
+});
+
+ipcMain.handle("dialog:select-folder", async () => {
+  const result = await dialog.showOpenDialog(mainWindow, {
+    title: "Select project folder",
+    properties: ["openDirectory"]
+  });
+
+  if (result.canceled || !result.filePaths.length) {
+    return null;
+  }
+
+  return inspectProject(result.filePaths[0]);
+});
+
+ipcMain.handle("dialog:select-icon", async () => {
+  const result = await dialog.showOpenDialog(mainWindow, {
+    title: "Select app icon",
+    properties: ["openFile"],
+    filters: [
+      { name: "PNG images", extensions: ["png"] },
+      { name: "All files", extensions: ["*"] }
+    ]
+  });
+
+  if (result.canceled || !result.filePaths.length) {
+    return null;
+  }
+
+  return result.filePaths[0];
+});
+
+ipcMain.handle("project:inspect", async (_event, projectRoot) => {
+  return inspectProject(projectRoot);
+});
+
+ipcMain.handle("doctor:run", async (_event, projectRoot) => {
+  const report = await runDoctor({ projectRoot });
+  return {
+    ok: report.ok,
+    report,
+    text: formatDoctorReport(report)
+  };
+});
+
+ipcMain.handle("install:android-requirements", async (event) => {
+  const approved = await askAndroidInstallPermission();
+  if (!approved) {
+    return {
+      ok: false,
+      canceled: true,
+      message: "Installation canceled by user."
+    };
+  }
+
+  const sender = event.sender;
+
+  try {
+    const runtime = getRuntimeEnvironment();
+    const sdkManager = sdkManagerPath(runtime);
+    sendInstallLog(sender, "Preparing Android SDK requirements.", "system");
+
+    if (sdkManager && await pathExists(sdkManager)) {
+      await installWithSdkManager(sender, sdkManager, runtime);
+    } else {
+      await installWithWingetAndroidCli(sender);
+    }
+
+    return {
+      ok: true,
+      message: "Android SDK requirements installed."
+    };
+  } catch (error) {
+    sendInstallLog(sender, error.message, "error");
+    return {
+      ok: false,
+      message: error.message
+    };
+  }
+});
+
+ipcMain.handle("build:run", async (event, options) => {
+  const buildOptions = cleanBuildOptions(options);
+  const sendLog = (line, kind = "raw") => {
+    event.sender.send("build:log", {
+      line,
+      kind,
+      time: new Date().toISOString()
+    });
+  };
+
+  try {
+    sendLog("Starting html2apk build.", "system");
+    const result = await buildApk({
+      ...buildOptions,
+      onLog: (line) => sendLog(line)
+    });
+    sendLog(`APK generated: ${result.apkPath}`, "success");
+    return {
+      ok: true,
+      result
+    };
+  } catch (error) {
+    sendLog(error.message, "error");
+    return {
+      ok: false,
+      message: error.message,
+      logs: error.logs || [],
+      buildDir: error.buildDir || null
+    };
+  }
+});
+
+ipcMain.handle("shell:open-path", async (_event, targetPath) => {
+  if (!targetPath) {
+    return false;
+  }
+  await shell.openPath(targetPath);
+  return true;
+});
+
+ipcMain.handle("shell:show-item", async (_event, targetPath) => {
+  if (!targetPath) {
+    return false;
+  }
+  shell.showItemInFolder(targetPath);
+  return true;
+});

package/src/desktop/preload.js

@@ -0,0 +1,30 @@
+"use strict";
+
+const { contextBridge, ipcRenderer, webUtils } = require("electron");
+
+contextBridge.exposeInMainWorld("html2apkDesktop", {
+  appInfo: () => ipcRenderer.invoke("app:info"),
+  selectFolder: () => ipcRenderer.invoke("dialog:select-folder"),
+  selectIcon: () => ipcRenderer.invoke("dialog:select-icon"),
+  inspectProject: (projectRoot) => ipcRenderer.invoke("project:inspect", projectRoot),
+  runDoctor: (projectRoot) => ipcRenderer.invoke("doctor:run", projectRoot),
+  installAndroidRequirements: () => ipcRenderer.invoke("install:android-requirements"),
+  runBuild: (options) => ipcRenderer.invoke("build:run", options),
+  openPath: (targetPath) => ipcRenderer.invoke("shell:open-path", targetPath),
+  showItem: (targetPath) => ipcRenderer.invoke("shell:show-item", targetPath),
+  minimizeWindow: () => ipcRenderer.invoke("window:minimize"),
+  toggleMaximizeWindow: () => ipcRenderer.invoke("window:toggle-maximize"),
+  closeWindow: () => ipcRenderer.invoke("window:close"),
+  setWindowTheme: (theme) => ipcRenderer.invoke("window:set-theme", theme),
+  pathForFile: (file) => webUtils.getPathForFile(file),
+  onBuildLog: (listener) => {
+    const handler = (_event, payload) => listener(payload);
+    ipcRenderer.on("build:log", handler);
+    return () => ipcRenderer.removeListener("build:log", handler);
+  },
+  onInstallLog: (listener) => {
+    const handler = (_event, payload) => listener(payload);
+    ipcRenderer.on("install:log", handler);
+    return () => ipcRenderer.removeListener("install:log", handler);
+  }
+});