Try MacOS build (#91)

Author: fonsp

.erb/scripts/beforePack.js

@@ -18,22 +18,42 @@ const JULIA_VERSION_PARTS = [1, 10, 10];
 const JULIA_VERSION = JULIA_VERSION_PARTS.join('.');
 const JULIA_VERSION_MINOR = JULIA_VERSION_PARTS.slice(0, 2).join('.');
 
-const JULIA_URL = `https://julialang-s3.julialang.org/bin/winnt/x64/${JULIA_VERSION_MINOR}/julia-${JULIA_VERSION}-win64.zip`;
+// Detect platform
+const platform = process.platform;
+const arch = process.arch === 'arm64' ? 'aarch64' : 'x64';
 
-const ZIP_NAME = `julia-${JULIA_VERSION}-win64.zip`;
-const JULIA_DIR_NAME = `julia-${JULIA_VERSION}`;
+let JULIA_URL, ZIP_NAME, JULIA_DIR_NAME, JULIA_EXECUTABLE;
+
+if (platform === 'win32') {
+  ZIP_NAME = `julia-${JULIA_VERSION}-win64.zip`;
+  JULIA_URL = `https://julialang-s3.julialang.org/bin/winnt/x64/${JULIA_VERSION_MINOR}/${ZIP_NAME}`;
+  JULIA_DIR_NAME = `julia-${JULIA_VERSION}`;
+  JULIA_EXECUTABLE = 'julia.exe';
+} else if (platform === 'darwin') {
+  // macOS
+  const macArch = arch === 'aarch64' ? 'aarch64' : 'x64';
+  ZIP_NAME = `julia-${JULIA_VERSION}-mac${arch === 'aarch64' ? 'aarch64' : '64'}.dmg`;
+  JULIA_URL = `https://julialang-s3.julialang.org/bin/mac/${macArch}/${JULIA_VERSION_MINOR}/${ZIP_NAME}`;
+  JULIA_DIR_NAME = `julia-${JULIA_VERSION}`;
+  JULIA_EXECUTABLE = 'julia';
+} else {
+  // Linux
+  throw new Error('Linux is not supported');
+}
 
 const DEPOT_NAME = `julia_depot`;
 
 const downloadJulia = async () => {
-  const spinner = createSpinner(`\tDownloading Julia ${JULIA_VERSION}`).start();
+  const spinner = createSpinner(
+    `\tDownloading Julia ${JULIA_VERSION} for ${platform}`,
+  ).start();
   const writer = fs.createWriteStream(path.join(assetPath, ZIP_NAME));
 
   const response = await axios.get(JULIA_URL, {
     responseType: 'stream',
     onDownloadProgress: (progressEvent) => {
       const percentage = Math.round(
-        (progressEvent.loaded * 100) / progressEvent.total
+        (progressEvent.loaded * 100) / progressEvent.total,
       );
       spinner
         .update({ text: `\tDownloading Julia ${JULIA_VERSION} ${percentage}%` })
@@ -56,17 +76,22 @@ const downloadJulia = async () => {
       reject(e);
     });
     writer.on('finish', (args) => {
-      spinner.success({ text: '\tDownloaded Julia', mark: '✓' });
+      spinner.success({
+        text: `\tDownloaded Julia (for ${platform}) (size: ${(response.data.length / 1024 / 1024).toFixed(2)} MB)`,
+        mark: '✓',
+      });
       resolve(args);
     });
   });
 };
 
 const precompilePluto = async ({ julia_path }) => {
+  // TODO: You need to add PackageCompiler to some environment for this to work.
+
   const SYSIMAGE_LOCATION = path.join(
     assetPath,
     // TODO: auto version number
-    'pluto.so'
+    'pluto.so',
   );
 
   // immediately return if the sysimage has already been compiled
@@ -77,7 +102,7 @@ const precompilePluto = async ({ julia_path }) => {
   const PRECOMPILE_SCRIPT_LOCATION = path.join(assetPath, 'precompile.jl');
   const PRECOMPILE_EXECUTION_LOCATION = path.join(
     assetPath,
-    'precompile_execution.jl'
+    'precompile_execution.jl',
   );
 
   const res = spawn(julia_path, [
@@ -124,7 +149,7 @@ const prepareJuliaDepot = async ({ julia_path }) => {
       env: {
         JULIA_DEPOT_PATH: DEPOT_LOCATION,
       },
-    }
+    },
   );
 
   res.stderr.on('data', (data) => {
@@ -146,35 +171,130 @@ const prepareJuliaDepot = async ({ julia_path }) => {
     recursive: true,
   });
 
+  // Fix file permissions on macOS to prevent code signing issues
+  if (platform === 'darwin') {
+    // (🤖🤖 This if block is AI written and not reviewed.)
+    try {
+      // First, make files writable so we can remove extended attributes
+      execSync(`find "${DEPOT_LOCATION}" -type f -exec chmod u+w {} +`, {
+        stdio: 'ignore',
+      });
+      execSync(`find "${DEPOT_LOCATION}" -type d -exec chmod u+w {} +`, {
+        stdio: 'ignore',
+      });
+      // Remove extended attributes (quarantine, etc.) that can interfere with code signing
+      execSync(`xattr -rc "${DEPOT_LOCATION}" 2>/dev/null || true`, {
+        stdio: 'ignore',
+      });
+      // Set final correct permissions: 644 for files, 755 for directories
+      execSync(`find "${DEPOT_LOCATION}" -type f -exec chmod 644 {} +`, {
+        stdio: 'ignore',
+      });
+      execSync(`find "${DEPOT_LOCATION}" -type d -exec chmod 755 {} +`, {
+        stdio: 'ignore',
+      });
+      console.info(
+        'Fixed file permissions and removed extended attributes in DEPOT',
+      );
+    } catch (error) {
+      console.warn('Warning: Could not fix file permissions:', error.message);
+    }
+  }
+
   console.info('DEPOT preparation success', DEPOT_LOCATION);
 };
 
+/**  (🤖🤖 This function is AI written and not reviewed.) */
+const extractJulia = async () => {
+  const spinner1 = createSpinner(`\tExtracting: ${ZIP_NAME}`).start();
+  fs.rmSync(path.join(assetPath, JULIA_DIR_NAME), {
+    force: true,
+    recursive: true,
+  });
+
+  if (platform === 'win32') {
+    // Windows: extract zip
+    await unzip(path.join(assetPath, ZIP_NAME), { dir: assetPath });
+  } else if (platform === 'darwin') {
+    // macOS: mount DMG and copy contents
+    const dmgPath = path.join(assetPath, ZIP_NAME);
+    const mountPoint = path.join(assetPath, 'julia_mount');
+
+    // Create mount point if it doesn't exist
+    if (!fs.existsSync(mountPoint)) {
+      fs.mkdirSync(mountPoint, { recursive: true });
+    }
+
+    // Mount the DMG
+    execSync(`hdiutil attach "${dmgPath}" -mountpoint "${mountPoint}" -quiet`);
+
+    try {
+      // Find the Julia app bundle in the mounted DMG
+      const mountedContents = fs.readdirSync(mountPoint);
+      const juliaApp = mountedContents.find((item) =>
+        item.startsWith('Julia-'),
+      );
+
+      if (!juliaApp) {
+        throw new Error('Could not find Julia app in DMG');
+      }
+
+      const juliaAppPath = path.join(mountPoint, juliaApp);
+      const juliaContentsPath = path.join(
+        juliaAppPath,
+        'Contents',
+        'Resources',
+        'julia',
+      );
+      const targetPath = path.join(assetPath, JULIA_DIR_NAME);
+
+      // Copy Julia contents to target directory
+      if (fs.existsSync(juliaContentsPath)) {
+        // Copy the entire julia directory
+        execSync(`cp -R "${juliaContentsPath}" "${targetPath}"`);
+      } else {
+        throw new Error('Could not find Julia contents in app bundle');
+      }
+    } finally {
+      // Unmount the DMG
+      execSync(`hdiutil detach "${mountPoint}" -quiet`);
+      if (fs.existsSync(mountPoint)) {
+        fs.rmSync(mountPoint, { recursive: true, force: true });
+      }
+    }
+  } else {
+    throw new Error('Linux is not supported');
+    // Linux: extract tar.gz
+    execSync(`tar -xzf "${path.join(assetPath, ZIP_NAME)}" -C "${assetPath}"`);
+  }
+
+  fs.rmSync(path.join(assetPath, ZIP_NAME), {
+    force: true,
+  });
+  spinner1.success({ text: '\tExtracted!', mark: '✓' });
+};
+
 exports.default = async (context) => {
   let files = fs.readdirSync(assetPath);
 
   if (!files.includes(JULIA_DIR_NAME)) {
     await downloadJulia();
-    // files = fs.readdirSync(assetPath);
-
-    const spinner1 = createSpinner(`\tExtracting: ${ZIP_NAME}`).start();
-    fs.rmSync(path.join(assetPath, JULIA_DIR_NAME), {
-      force: true,
-      recursive: true,
-    });
-    await unzip(path.join(assetPath, ZIP_NAME), { dir: assetPath });
-    fs.rmSync(path.join(assetPath, ZIP_NAME), {
-      force: true,
-    });
-    spinner1.success({ text: '\tExtracted!', mark: '✓' });
+    await extractJulia();
   }
 
+  const juliaPath = path.join(
+    assetPath,
+    JULIA_DIR_NAME,
+    'bin',
+    JULIA_EXECUTABLE,
+  );
+
   await prepareJuliaDepot({
-    julia_path: path.join(assetPath, JULIA_DIR_NAME, 'bin', 'julia.exe'),
+    julia_path: juliaPath,
   });
 
   // NOT DOING THIS, see https://github.com/JuliaPluto/PlutoDesktop/issues/56
-  //  maybe we are... (CB)
-  await precompilePluto({
-    julia_path: path.join(assetPath, JULIA_DIR_NAME, 'bin', 'julia.exe'),
-  });
+  // await precompilePluto({
+  //   julia_path: juliaPath,
+  // });
 };

.erb/scripts/beforeSign.js

@@ -0,0 +1,150 @@
+/*
+
+
+
+
+
+🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖
+
+This file is completely written by AI and not really reviewed. It's not working super well.
+
+
+
+*/
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Ensures all components of the macOS app are signed consistently with ad-hoc signature
+ * This is necessary when no Developer ID certificate is available
+ * This runs in the afterPack hook, which executes after packaging but before electron-builder's signing step
+ */
+exports.default = async function afterPack(context) {
+  const { electronPlatformName, appOutDir } = context;
+
+  if (electronPlatformName !== 'darwin') {
+    return;
+  }
+
+  const appName = context.packager.appInfo.productFilename;
+  const appPath = path.join(appOutDir, `${appName}.app`);
+
+  if (!fs.existsSync(appPath)) {
+    console.warn('App bundle not found, skipping beforeSign');
+    return;
+  }
+
+  // Check if we have a valid Developer ID certificate
+  try {
+    const identities = execSync('security find-identity -v -p codesigning', {
+      encoding: 'utf8',
+    });
+    const hasValidIdentity = identities.includes('Developer ID Application');
+
+    if (hasValidIdentity) {
+      // Valid certificate exists, let electron-builder handle signing normally
+      return;
+    }
+  } catch (error) {
+    // No valid certificate found, proceed with ad-hoc signing
+  }
+
+  console.log(
+    'No valid Developer ID certificate found, ensuring ad-hoc signing...',
+  );
+
+  const frameworksPath = path.join(appPath, 'Contents', 'Frameworks');
+  const electronFrameworkPath = path.join(
+    frameworksPath,
+    'Electron Framework.framework',
+  );
+
+  // Sign Electron Framework first (deep signing)
+  if (fs.existsSync(electronFrameworkPath)) {
+    try {
+      // Sign the framework binary first
+      const frameworkBinary = path.join(
+        electronFrameworkPath,
+        'Versions',
+        'A',
+        'Electron Framework',
+      );
+      if (fs.existsSync(frameworkBinary)) {
+        execSync(
+          `codesign --force --sign - --timestamp=none --options runtime "${frameworkBinary}"`,
+          { stdio: 'inherit' },
+        );
+      }
+      // Then sign the framework bundle
+      execSync(
+        `codesign --force --sign - --timestamp=none "${electronFrameworkPath}"`,
+        { stdio: 'inherit' },
+      );
+      console.log('Signed Electron Framework with ad-hoc signature');
+    } catch (error) {
+      console.warn('Failed to sign Electron Framework:', error.message);
+    }
+  }
+
+  // Sign all other frameworks
+  if (fs.existsSync(frameworksPath)) {
+    const frameworks = fs.readdirSync(frameworksPath);
+    for (const framework of frameworks) {
+      if (framework === 'Electron Framework.framework') {
+        continue; // Already handled above
+      }
+
+      const frameworkPath = path.join(frameworksPath, framework);
+      if (
+        fs.statSync(frameworkPath).isDirectory() &&
+        framework.endsWith('.framework')
+      ) {
+        const binaryName = framework.replace('.framework', '');
+        const binaryPath = path.join(frameworkPath, binaryName);
+        if (fs.existsSync(binaryPath)) {
+          try {
+            execSync(
+              `codesign --force --sign - --timestamp=none --options runtime "${binaryPath}"`,
+              { stdio: 'inherit' },
+            );
+            execSync(
+              `codesign --force --sign - --timestamp=none "${frameworkPath}"`,
+              { stdio: 'inherit' },
+            );
+            console.log(`Signed ${framework} with ad-hoc signature`);
+          } catch (error) {
+            console.warn(`Failed to sign ${framework}:`, error.message);
+          }
+        }
+      }
+    }
+  }
+
+  // Sign the main executable
+  const mainExecutable = path.join(appPath, 'Contents', 'MacOS', appName);
+  if (fs.existsSync(mainExecutable)) {
+    try {
+      execSync(
+        `codesign --force --sign - --timestamp=none --options runtime "${mainExecutable}"`,
+        { stdio: 'inherit' },
+      );
+      console.log('Signed main executable with ad-hoc signature');
+    } catch (error) {
+      console.warn('Failed to sign main executable:', error.message);
+    }
+  }
+
+  // Finally, sign the entire app bundle (this ensures all components have matching Team IDs)
+  // Note: We don't use --deep as it's deprecated, and we've already signed all components
+  try {
+    execSync(
+      `codesign --force --sign - --timestamp=none --options runtime "${appPath}"`,
+      { stdio: 'inherit' },
+    );
+    console.log('Signed entire app bundle with ad-hoc signature');
+  } catch (error) {
+    console.warn('Failed to sign app bundle:', error.message);
+  }
+};