java_handler.json

[
  "   * install-java - เธ”เธฒเธงเธ™เนŒเน‚เธซเธฅเธ”เนเธฅเธฐเธ•เธดเธ”เธ•เธฑเน‰เธ‡ Java (with progress events)",
  "   */",
  "  ipcMain.handle(\"install-java\", async (_event, majorVersion: number) => {",
  "    const https = await import(\"node:https\");",
  "    const { createWriteStream } = await import(\"node:fs\");",
  "    const { spawn } = await import(\"node:child_process\");",
  "    const native = getNativeModule() as any;",
  "",
  "    console.log(`[Java] Starting installation of Java ${majorVersion}`);",
  "",
  "    // Helper to send progress to renderer",
  "    const sendProgress = (phase: string, percent: number, message: string) => {",
  "      const mainWindow = getMainWindow();",
  "      if (mainWindow) {",
  "        mainWindow.webContents.send(\"java-install-progress\", {",
  "          majorVersion,",
  "          phase,",
  "          percent,",
  "          message,",
  "        });",
  "      }",
  "    };",
  "",
  "    try {",
  "      const featureVersion = majorVersion;",
  "",
  "      const javaBaseDir = path.join(getAppDataDir(), \"java\");",
  "      if (!fs.existsSync(javaBaseDir)) {",
  "        fs.mkdirSync(javaBaseDir, { recursive: true });",
  "      }",
  "",
  "      const existingJava = path.join(",
  "        javaBaseDir,",
  "        `jdk-${majorVersion}`,",
  "        \"bin\",",
  "        \"java.exe\",",
  "      );",
  "      if (fs.existsSync(existingJava)) {",
  "        console.log(",
  "          `[Java] Java ${majorVersion} already exists at ${existingJava}`,",
  "        );",
  "        return { ok: true, path: existingJava };",
  "      }",
  "",
  "      if (typeof native.installJavaRuntime === \"function\") {",
  "        try {",
  "          sendProgress(\"fetch\", 10, \"Preparing Java installation...\");",
  "          const installedPath = (await native.installJavaRuntime(",
  "            majorVersion,",
  "            javaBaseDir,",
  "          )) as string;",
  "          sendProgress(\"complete\", 100, \"Java installation complete\");",
  "          return { ok: true, path: installedPath };",
  "        } catch (nativeInstallError: any) {",
  "          console.warn(\"[Java] Native installJavaRuntime failed, fallback to JS:\", nativeInstallError?.message || nativeInstallError);",
  "        }",
  "      }",
  "",
  "      sendProgress(\"fetch\", 0, \"เธเธณเธฅเธฑเธ‡เธ”เธถเธ‡เธ‚เน‰เธญเธกเธนเธฅ...\");",
  "      console.log(",
  "        `[Java] Fetching Azul Zulu metadata for Java ${featureVersion}...`,",
  "      );",
  "",
  "      const azulOs =",
  "        process.platform === \"win32\"",
  "          ? \"windows\"",
  "          : process.platform === \"darwin\"",
  "            ? \"macos\"",
  "            : \"linux\";",
  "      const azulArch =",
  "        process.arch === \"arm64\"",
  "          ? \"aarch64\"",
  "          : process.arch === \"ia32\"",
  "            ? \"x86\"",
  "            : \"x64\";",
  "      const azulQuery = new URLSearchParams({",
  "        java_version: `${featureVersion}`,",
  "        os: azulOs,",
  "        arch: azulArch,",
  "        archive_type: \"zip\",",
  "        java_package_type: \"jdk\",",
  "        javafx_bundled: \"false\",",
  "        release_status: \"ga\",",
  "        availability_types: \"CA\",",
  "        certifications: \"tck\",",
  "        java_package_features: \"headful\",",
  "        latest: \"true\",",
  "        page: \"1\",",
  "        page_size: \"100\",",
  "      });",
  "      const apiUrl = `https://api.azul.com/metadata/v1/zulu/packages/?${azulQuery.toString()}`;",
  "      const apiResponse = await new Promise<any>((resolve, reject) => {",
  "        https",
  "          .get(apiUrl, (res) => {",
  "            let data = \"\";",
  "            res.on(\"data\", (chunk) => (data += chunk));",
  "            res.on(\"end\", () => {",
  "              try {",
  "                resolve(JSON.parse(data));",
  "              } catch (e) {",
  "                reject(",
  "                  new Error(`Invalid API response: ${data.substring(0, 200)}`),",
  "                );",
  "              }",
  "            });",
  "          })",
  "          .on(\"error\", reject);",
  "      });",
  "",
  "      const zuluPackage = Array.isArray(apiResponse)",
  "        ? (apiResponse.find((entry: any) => entry?.latest && entry?.download_url) ??",
  "            apiResponse.find((entry: any) => entry?.download_url))",
  "        : null;",
  "      if (!zuluPackage) {",
  "        console.log(",
  "          `[Java] No Java ${majorVersion} found in Azul Zulu metadata`,",
  "        );",
  "        return {",
  "          ok: false,",
  "          error: `Java ${majorVersion} not found from Azul Zulu`,",
  "        };",
  "      }",
  "",
  "      const downloadUrl = zuluPackage.download_url;",
  "      const fileName =",
  "        zuluPackage.name ||",
  "        (typeof downloadUrl === \"string\"",
  "          ? downloadUrl.split(\"/\").pop()?.split(\"?\")[0]",
  "          : undefined);",
  "      const fileSize =",
  "        zuluPackage.size ||",
  "        zuluPackage.download_size ||",
  "        zuluPackage.filesize ||",
  "        0;",
  "      if (!downloadUrl || !fileName)",
  "        return { ok: false, error: \"เน„เธกเนˆเธžเธš download URL\" };",
  "",
  "      const fileSizeMB = Math.round(fileSize / 1024 / 1024);",
  "      sendProgress(",
  "        \"download\",",
  "        0,",
  "        `เธเธณเธฅเธฑเธ‡เธ”เธฒเธงเธ™เนŒเน‚เธซเธฅเธ” ${fileName} (${fileSizeMB}MB)...`,",
  "      );",
  "      console.log(`[Java] Downloading ${fileName} (${fileSizeMB}MB)...`);",
  "      const zipPath = path.join(javaBaseDir, fileName);",
  "",
  "      if (typeof native.downloadFile === \"function\") {",
  "        sendProgress(\"download\", 25, \"Downloading with native core...\");",
  "        const nativeResult = (await native.downloadFile(",
  "          downloadUrl,",
  "          zipPath,",
  "          undefined,",
  "          undefined,",
  "        )) as { success?: boolean; error?: string };",
  "        if (!nativeResult?.success) {",
  "          throw new Error(nativeResult?.error || \"Native Java download failed\");",
  "        }",
  "        sendProgress(\"download\", 100, \"Download complete\");",
  "      } else {",
  "        await new Promise<void>((resolve, reject) => {",
  "          const download = (url: string) => {",
  "            https",
  "              .get(url, (res) => {",
  "                if (res.statusCode === 301 || res.statusCode === 302) {",
  "                  if (res.headers.location) download(res.headers.location);",
  "                  return;",
  "                }",
  "                if (res.statusCode !== 200) {",
  "                  reject(new Error(`HTTP ${res.statusCode}`));",
  "                  return;",
  "                }",
  "                const file = createWriteStream(zipPath);",
  "                let downloaded = 0;",
  "                const total =",
  "                  parseInt(res.headers[\"content-length\"] || \"0\", 10) ||",
  "                  fileSize;",
  "",
  "                res.on(\"data\", (chunk) => {",
  "                  downloaded += chunk.length;",
  "                  const percent =",
  "                    total > 0 ? Math.round((downloaded / total) * 100) : 0;",
  "                  if (percent % 5 === 0 || downloaded === total) {",
  "                    const downloadedMB = Math.round(downloaded / 1024 / 1024);",
  "                    const totalMB = Math.round(total / 1024 / 1024);",
  "                    sendProgress(",
  "                      \"download\",",
  "                      percent,",
  "                      `Downloading ${downloadedMB}/${totalMB} MB (${percent}%)`,",
  "                    );",
  "                  }",
  "                });",
  "",
  "                res.pipe(file);",
  "                file.on(\"finish\", () => {",
  "                  file.close();",
  "                  console.log(`[Java] Download complete: ${zipPath}`);",
  "                  resolve();",
  "                });",
  "              })",
  "              .on(\"error\", reject);",
  "          };",
  "          download(downloadUrl);",
  "        });",
  "      }",
  "",
  "      const extractDir = path.join(javaBaseDir, `temp-${majorVersion}`);",
  "      sendProgress(\"extract\", 0, \"เธเธณเธฅเธฑเธ‡เนเธ•เธเน„เธŸเธฅเนŒ...\");",
  "      console.log(`[Java] Extracting to ${extractDir}...`);",
  "      if (fs.existsSync(extractDir)) fs.rmSync(extractDir, { recursive: true });",
  "      fs.mkdirSync(extractDir, { recursive: true });",
  "",
  "      const toSignedExitCode = (code: number | null): number | null => {",
  "        if (code === null) return null;",
  "        return code > 0x7fffffff ? code - 0x100000000 : code;",
  "      };",
  "",
  "      const runExtractAttempt = (",
  "        label: string,",
  "        command: string,",
  "        args: string[],",
  "      ): Promise<void> => {",
  "        return new Promise<void>((resolve, reject) => {",
  "          let stderr = \"\";",
  "          let stdout = \"\";",
  "          const child = spawn(command, args, {",
  "            windowsHide: true,",
  "          });",
  "",
  "          child.stdout?.on(\"data\", (chunk) => {",
  "            stdout += chunk.toString();",
  "          });",
  "",
  "          child.stderr?.on(\"data\", (chunk) => {",
  "            stderr += chunk.toString();",
  "          });",
  "",
  "          child.on(\"close\", (code) => {",
  "            if (code === 0) {",
  "              resolve();",
  "              return;",
  "            }",
  "",
  "            const signedCode = toSignedExitCode(code);",
  "            const codeText =",
  "              signedCode !== null && signedCode !== code",
  "                ? `${code} (signed ${signedCode})`",
  "                : `${code}`;",
  "            const detail = [stderr.trim(), stdout.trim()]",
  "              .filter(Boolean)",
  "              .join(\"\\n\");",
  "            reject(",
  "              new Error(",
  "                `${label} failed with code ${codeText}${detail ? `: ${detail}` : \"\"}`,",
  "              ),",
  "            );",
  "          });",
  "",
  "          child.on(\"error\", (err) => {",
  "            reject(new Error(`${label} spawn error: ${err.message}`));",
  "          });",
  "        });",
  "      };",
  "",
  "      let extractedByNative = false;",
  "      if (typeof native.extractZipAsync === \"function\" || typeof native.extractZip === \"function\") {",
  "        try {",
  "          const nativeExtract =",
  "            typeof native.extractZipAsync === \"function\"",
  "              ? await native.extractZipAsync(zipPath, extractDir, undefined)",
  "              : await native.extractZip(zipPath, extractDir, undefined);",
  "          if (nativeExtract?.success === false) {",
  "            throw new Error(nativeExtract?.error || \"Native extract returned unsuccessful result\");",
  "          }",
  "          extractedByNative = true;",
  "          sendProgress(\"extract\", 100, \"Extraction complete\");",
  "        } catch (nativeExtractError: any) {",
  "          console.warn(\"[Java] Native extract failed, fallback to shell tools:\", nativeExtractError?.message || nativeExtractError);",
  "          if (fs.existsSync(extractDir))",
  "            fs.rmSync(extractDir, { recursive: true, force: true });",
  "          fs.mkdirSync(extractDir, { recursive: true });",
  "        }",
  "      }",
  "",
  "      if (!extractedByNative) {",
  "      const psZipPath = zipPath.replace(/'/g, \"''\");",
  "      const psExtractDir = extractDir.replace(/'/g, \"''\");",
  "      const extractAttempts = [",
  "        {",
  "          label: \"PowerShell Expand-Archive\",",
  "          command: \"powershell\",",
  "          args: [",
  "            \"-NoProfile\",",
  "            \"-Command\",",
  "            `$ErrorActionPreference = 'Stop'; Expand-Archive -LiteralPath '${psZipPath}' -DestinationPath '${psExtractDir}' -Force`,",
  "          ],",
  "        },",
  "        {",
  "          label: \"PowerShell ZipFile\",",
  "          command: \"powershell\",",
  "          args: [",
  "            \"-NoProfile\",",
  "            \"-Command\",",
  "            `$ErrorActionPreference = 'Stop'; Add-Type -AssemblyName System.IO.Compression.FileSystem; [System.IO.Compression.ZipFile]::ExtractToDirectory('${psZipPath}', '${psExtractDir}', $true)`,",
  "          ],",
  "        },",
  "        {",
  "          label: \"tar\",",
  "          command: \"tar\",",
  "          args: [\"-xf\", zipPath, \"-C\", extractDir],",
  "        },",
  "      ] as const;",
  "",
  "      // Update progress periodically during extraction",
  "      let extractPercent = 0;",
  "      const progressInterval = setInterval(() => {",
  "        extractPercent = Math.min(extractPercent + 10, 90);",
  "        sendProgress(",
  "          \"extract\",",
  "          extractPercent,",
  "          `Extracting files... ${extractPercent}%`,",
  "        );",
  "      }, 1000);",
  "",
  "      try {",
  "        let extracted = false;",
  "        let lastError: Error | null = null;",
  "",
  "        for (const attempt of extractAttempts) {",
  "          try {",
  "            console.log(`[Java] Extract attempt: ${attempt.label}`);",
  "            await runExtractAttempt(attempt.label, attempt.command, [",
  "              ...attempt.args,",
  "            ]);",
  "            extracted = true;",
  "            break;",
  "          } catch (error: any) {",
  "            lastError =",
  "              error instanceof Error ? error : new Error(String(error));",
  "            console.warn(",
  "              `[Java] ${attempt.label} failed: ${lastError.message}`,",
  "            );",
  "            if (fs.existsSync(extractDir))",
  "              fs.rmSync(extractDir, { recursive: true, force: true });",
  "            fs.mkdirSync(extractDir, { recursive: true });",
  "          }",
  "        }",
  "",
  "        if (!extracted) {",
  "          throw lastError || new Error(\"Extract failed\");",
  "        }",
  "",
  "        sendProgress(\"extract\", 100, \"Extraction complete\");",
  "      } finally {",
  "        clearInterval(progressInterval);",
  "      }",
  "",
  "",
  "      }",
  "      fs.unlinkSync(zipPath);",
  "",
  "      const extractedDirs = fs.readdirSync(extractDir);",
  "      if (extractedDirs.length === 0) {",
  "        console.log(`[Java] No directories found after extract`);",
  "        return { ok: false, error: \"Extract failed - no directories\" };",
  "      }",
  "",
  "      sendProgress(\"install\", 90, \"เธเธณเธฅเธฑเธ‡เธ•เธดเธ”เธ•เธฑเน‰เธ‡...\");",
  "      const sourcePath = path.join(extractDir, extractedDirs[0]);",
  "      const targetPath = path.join(javaBaseDir, `jdk-${majorVersion}`);",
  "",
  "      if (fs.existsSync(targetPath)) fs.rmSync(targetPath, { recursive: true });",
  "      fs.renameSync(sourcePath, targetPath);",
  "      fs.rmSync(extractDir, { recursive: true });",
  "",
  "      const javaExePath = path.join(targetPath, \"bin\", \"java.exe\");",
  "      if (!fs.existsSync(javaExePath))",
  "        return { ok: false, error: \"เน„เธกเนˆเธžเธš java.exe\" };",
  "",
  "      sendProgress(\"complete\", 100, \"เธ•เธดเธ”เธ•เธฑเน‰เธ‡เธชเธณเน€เธฃเน‡เธˆ!\");",
  "      return { ok: true, path: javaExePath };",
  "    } catch (error: any) {",
  "      sendProgress(\"error\", 0, error.message);",
  "      return { ok: false, error: error.message };",
  "    }",
  "  });",
  "",
  "  /**",
  "   * delete-java - เธฅเธš Java เธ—เธตเนˆเธ•เธดเธ”เธ•เธฑเน‰เธ‡เน‚เธ”เธข launcher",
  "   */",
  "  ipcMain.handle(\"delete-java\", async (_event, majorVersion: number) => {",
  "    try {",
  "      const javaBaseDir = path.join(getAppDataDir(), \"java\");",
  "      const javaDir = path.join(javaBaseDir, `jdk-${majorVersion}`);",
  "",
  "      if (!fs.existsSync(javaDir)) {",
  "        return { ok: true, message: `เน„เธกเนˆเธžเธš Java ${majorVersion}` };",
  "      }",
  "",
  "      fs.rmSync(javaDir, { recursive: true, force: true });",
  "      return { ok: true, message: `เธฅเธš Java ${majorVersion} เธชเธณเน€เธฃเน‡เธˆ` };",
  "    } catch (error: any) {",
  "      return { ok: false, error: error.message };",
  "    }",
  "  });",
  "",
  "  ipcMain.handle(",
  "    \"minecraft-get-profile\",",
  "    async (_event, options?: { forceRefresh?: boolean }) => {",
  "      try {",
  "        const session = getSession();",
  "        if (!session || session.type !== \"microsoft\") {",
  "          return { ok: false, error: \"Microsoft account is required.\" };",
  "        }",
  "",
  "        const forceRefresh = !!options?.forceRefresh;",
  "        const sessionKey = getMinecraftProfileCacheKey(session);",
  "        if (!forceRefresh) {",
  "          const cachedProfile = getCachedMinecraftProfile(sessionKey);",
  "          if (cachedProfile) {",
  "            return { ok: true, profile: cachedProfile.profile };",
  "          }",
  "        }",
  "",
  "        const refreshResult = await refreshMicrosoftTokenIfNeeded();",
  "        if (!refreshResult.ok) {",
  "          return {",
  "            ok: false,",
  "            error: refreshResult.error || \"Could not refresh Microsoft token.\",",
  "            requiresRelogin: refreshResult.requiresRelogin || false,",
  "          };",
  "        }",
  "",
  "        const accessToken =",
  "          refreshResult.session?.accessToken || session.accessToken;",
  "        if (!accessToken) {",
  "          return { ok: false, error: \"Microsoft access token not found.\" };",
  "        }",
  "",
  "        const profileResult = await fetchMinecraftProfile(accessToken);",
  "        if (profileResult.ok && profileResult.profile) {"
]