@vscode/gulp-electron 1.33.0

package/README.md

@@ -0,0 +1,117 @@
+**Deprecated**
+
+Please use the official way of requiring Electron: https://electronjs.org/docs/tutorial/first-app
+
+--
+
+# @vscode/gulp-electron
+
+### Installation
+
+```bash
+npm install --save-dev @vscode/gulp-electron
+```
+
+### Usage
+
+You can use this module in two distinct ways: **to package your application** and/or
+**to download a version of Electron** to disk.
+
+#### How to Package Your Application
+
+You should source your app's files using `gulp.src` and pipe them through
+`@vscode/gulp-electron`. The following task will create your application in
+the `app` folder, ready for launch.
+
+```javascript
+var gulp = require("gulp");
+var symdest = require("gulp-symdest");
+var electron = require("@vscode/gulp-electron");
+
+gulp.task("default", function () {
+  return gulp
+    .src("src/**")
+    .pipe(electron({ version: "0.34.1", platform: "darwin" }))
+    .pipe(symdest("app"));
+});
+```
+
+**Note:** It is important to use `gulp-symdest` only because of the OS X
+platform. An application bundle has symlinks within and if you use `gulp.dest`
+to pipe the built app to disk, those will be missing. `symdest` will make
+sure symlinks are taken into account.
+
+Finally, you can always pipe it to a **zip archive** for easy distribution.
+[joaomoreno/gulp-vinyl-zip](https://github.com/joaomoreno/gulp-vinyl-zip) is recommended:
+
+```javascript
+var gulp = require("gulp");
+var zip = require("gulp-vinyl-zip");
+var electron = require("@vscode/gulp-electron");
+
+gulp.task("default", function () {
+  return gulp
+    .src("src/**")
+    .pipe(electron({ version: "0.34.1", platform: "darwin" }))
+    .pipe(zip.dest("app-darwin.zip"));
+});
+```
+
+#### How to Download Electron
+
+There's also a very handy export `electron.dest()` function that
+makes sure you always have the exact version of Electron in a directory:
+
+```javascript
+var gulp = require("gulp");
+var electron = require("@vscode/gulp-electron");
+
+gulp.task("default", function () {
+  return electron.dest("electron-build", {
+    version: "0.34.1",
+    platform: "darwin",
+  });
+});
+```
+
+This will place a vanilla Electron build into the `electron-build` directory.
+If you run it consecutively and it detects that the version in the destination directory
+is the intended one, it will end up in a no-op. Else it will download the provided version
+and replace it.
+
+### Options
+
+You **must** provide the following options:
+
+- `version` - the [Electron version](https://github.com/atom/electron/releases) to use
+- `platform` - kind of OS (`darwin`, `linux`, `win32`)
+
+The following options are **optional**:
+
+- `quiet` - suppress a progress bar when downloading
+- `token` - GitHub access token(to avoid request limit. You can grab it [here](https://github.com/settings/tokens))
+
+- `arch` - the processor architecture (`ia32`, `x64`)
+
+- **Windows**
+
+  - `winIcon` - path to an `.ico` file
+  - `companyName` - company name
+  - `copyright` - copyright statement
+
+- **Darwin**
+
+  - `darwinIcon` - path to an `.icns` file
+  - `darwinHelpBookFolder` - the `CFBundleHelpBookFolder` value
+  - `darwinHelpBookName` - the `CFBundleHelpBookName` value
+  - `darwinBundleDocumentTypes` - ([reference](https://developer.apple.com/library/ios/documentation/filemanagement/conceptual/documentinteraction_topicsforios/Articles/RegisteringtheFileTypesYourAppSupports.html)) array of dictionaries, each containing the following structure:
+    - `name` - the `CFBundleTypeName` value
+    - `role` - the `CFBundleTypeRole` value
+    - `ostypes` - the `CFBundleTypeOSTypes` value, a `string` array
+    - `utis` - the `LSItemContentTypes` value, a `string` array
+    - `extensions` - the `CFBundleTypeExtensions` value, a `string` array of file extensions
+    - `iconFile` - the `CFBundleTypeIconFile` value
+  - `darwinForceDarkModeSupport` - Forces Mojave dark mode support to be enabled for older Electron versions
+
+- **Linux**
+  - `linuxExecutableName` - overwrite the name of the executable in Linux

package/azure-pipelines.yml

@@ -0,0 +1,40 @@
+trigger:
+  batch: true
+  branches:
+    include:
+      - main
+
+pr: [main]
+
+resources:
+  repositories:
+    - repository: templates
+      type: github
+      name: microsoft/vscode-engineering
+      ref: main
+      endpoint: Monaco
+
+parameters:
+  - name: publishPackage
+    displayName: 🚀 Publish
+    type: boolean
+    default: false
+
+extends:
+  template: azure-pipelines/npm-package/pipeline.yml@templates
+  parameters:
+    npmPackages:
+      - name: gulp-electron
+        buildSteps:
+          - script: npm ci
+        testPlatforms:
+          - name: Linux
+            nodeVersions: [14.x, 16.x, 17.x]
+          - name: MacOS
+            nodeVersions: [14.x, 16.x, 17.x]
+          - name: Windows
+            nodeVersions: [14.x, 16.x, 17.x]
+        testSteps:
+          - script: npm ci
+          - script: npm test
+        publishPackage: ${{ parameters.publishPackage }}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@vscode/gulp-electron",
+  "version": "1.33.0",
+  "description": "gulp plugin for packaging Electron into VS Code",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/microsoft/vscode-gulp-electron.git"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "keywords": [
+    "gulpplugin",
+    "atom",
+    "shell",
+    "atom-shell",
+    "electron",
+    "github"
+  ],
+  "author": "João Moreno",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/microsoft/vscode-gulp-electron/issues"
+  },
+  "homepage": "https://github.com/microsoft/vscode-gulp-electron",
+  "dependencies": {
+    "@electron/get": "^2.0.2",
+    "@octokit/rest": "^18.0.14",
+    "event-stream": "3.3.4",
+    "gulp-filter": "^5.1.0",
+    "gulp-rename": "1.2.2",
+    "gulp-symdest": "^1.2.0",
+    "gulp-vinyl-zip": "^2.1.2",
+    "mkdirp": "^0.5.1",
+    "plist": "^3.0.1",
+    "progress": "^1.1.8",
+    "rcedit": "^0.3.0",
+    "rimraf": "^2.4.2",
+    "semver": "^4.3.4",
+    "temp": "^0.8.3",
+    "vinyl": "^2.2.0",
+    "vinyl-fs": "^3.0.3"
+  },
+  "devDependencies": {
+    "gulp-buffer": "0.0.2",
+    "mocha": "^9.2.2"
+  }
+}

package/src/darwin.js

@@ -0,0 +1,410 @@
+"use strict";
+
+var path = require("path");
+var plist = require("plist");
+var es = require("event-stream");
+var vfs = require("vinyl-fs");
+var File = require("vinyl");
+var rename = require("gulp-rename");
+var semver = require("semver");
+
+function getOriginalAppName(opts) {
+  return semver.gte(opts.version, "0.24.0") ? "Electron" : "Atom";
+}
+
+function getOriginalAppFullName(opts) {
+  return getOriginalAppName(opts) + ".app";
+}
+
+function getAppName(opts) {
+  return (opts.productAppName || opts.productName) + ".app";
+}
+
+exports.getAppPath = function (opts) {
+  return getAppName(opts) + "/Contents/Resources/app";
+};
+
+function removeDefaultApp(opts) {
+  var defaultAppPath = path.join(
+    getOriginalAppFullName(opts),
+    "Contents",
+    "Resources",
+    "default_app"
+  );
+
+  return es.mapSync(function (f) {
+    if (!f.relative.startsWith(defaultAppPath)) {
+      return f;
+    }
+  });
+}
+
+function patchIcon(opts) {
+  if (!opts.darwinIcon) {
+    return es.through();
+  }
+
+  var resourcesPath = path.join(
+    getOriginalAppFullName(opts),
+    "Contents",
+    "Resources"
+  );
+  var iconName = semver.gte(opts.version, "0.24.0")
+    ? "electron.icns"
+    : "atom.icns";
+  var originalIconPath = path.join(resourcesPath, iconName);
+  var iconPath = path.join(resourcesPath, opts.productName + ".icns");
+  var pass = es.through();
+
+  // filter out original icon
+  var src = pass.pipe(
+    es.mapSync(function (f) {
+      if (f.relative !== originalIconPath) {
+        return f;
+      }
+    })
+  );
+
+  // add custom icon
+  var icon = vfs.src(opts.darwinIcon).pipe(rename(iconPath));
+
+  return es.duplex(pass, es.merge(src, icon));
+}
+
+function patchInfoPlist(opts) {
+  var contentsPath = path.join(getOriginalAppFullName(opts), "Contents");
+  var resourcesPath = path.join(contentsPath, "Resources");
+  var infoPlistPath = path.join(contentsPath, "Info.plist");
+  var didCloseIcons = false;
+
+  var icons = es.through();
+  var input = es.through();
+  var output = input.pipe(
+    es.map(function (f, cb) {
+      if (f.relative !== infoPlistPath) {
+        return cb(null, f);
+      }
+
+      var contents = "";
+
+      f.contents.on("error", function (err) {
+        cb(err);
+      });
+
+      f.contents.on("data", function (d) {
+        contents += d;
+      });
+
+      f.contents.on("end", function () {
+        var infoPlist = plist.parse(contents.toString("utf8"));
+
+        opts.darwinBundleIdentifier &&
+          (infoPlist["CFBundleIdentifier"] = opts.darwinBundleIdentifier);
+        opts.darwinApplicationCategoryType &&
+          (infoPlist["LSApplicationCategoryType"] =
+            opts.darwinApplicationCategoryType);
+        infoPlist["CFBundleName"] = opts.productName;
+        infoPlist["CFBundleDisplayName"] =
+          opts.productDisplayName || opts.productName;
+        infoPlist["CFBundleVersion"] = opts.productVersion;
+        infoPlist["CFBundleShortVersionString"] = opts.productVersion;
+        opts.copyright &&
+          (infoPlist["NSHumanReadableCopyright"] = opts.copyright);
+        infoPlist["CFBundleIconFile"] = opts.productName + ".icns";
+
+        if (opts.darwinExecutable) {
+          infoPlist["CFBundleExecutable"] = opts.darwinExecutable;
+        }
+
+        //Register the Application Help Book if it exists
+        if (opts.darwinHelpBookFolder && opts.darwinHelpBookName) {
+          infoPlist["CFBundleHelpBookFolder"] = opts.darwinHelpBookFolder;
+          infoPlist["CFBundleHelpBookName"] = opts.darwinHelpBookName;
+        }
+
+        if (opts.darwinBundleDocumentTypes) {
+          var iconsPaths = [];
+
+          infoPlist["CFBundleDocumentTypes"] = (
+            infoPlist["CFBundleDocumentTypes"] || []
+          ).concat(
+            opts.darwinBundleDocumentTypes.map(function (type) {
+              iconsPaths.push(type.iconFile);
+
+              var result = {
+                CFBundleTypeName: type.name,
+                CFBundleTypeRole: type.role,
+                CFBundleTypeOSTypes: type.ostypes,
+                CFBundleTypeExtensions: type.extensions,
+                CFBundleTypeIconFile: path.basename(type.iconFile),
+              };
+
+              if (type.utis) {
+                result["LSItemContentTypes"] = type.utis;
+              }
+
+              return result;
+            })
+          );
+
+          if (iconsPaths.length) {
+            didCloseIcons = true;
+            es.merge(
+              iconsPaths.map(function (iconPath) {
+                return vfs.src(iconPath).pipe(
+                  rename(function (path) {
+                    path.dirname = resourcesPath;
+                  })
+                );
+              })
+            ).pipe(icons);
+          }
+        }
+
+        if (opts.darwinBundleURLTypes) {
+          infoPlist["CFBundleURLTypes"] = opts.darwinBundleURLTypes.map(
+            function (type) {
+              return {
+                CFBundleTypeRole: type.role,
+                CFBundleURLName: type.name,
+                CFBundleURLSchemes: type.urlSchemes,
+              };
+            }
+          );
+        }
+
+        if (opts.darwinForceDarkModeSupport) {
+          infoPlist["NSRequiresAquaSystemAppearance"] = false;
+        }
+
+        f.contents = Buffer.from(plist.build(infoPlist), "utf8");
+        cb(null, f);
+      });
+    }))
+    .pipe(
+      es.through(
+        null,
+        function () {
+          if (!didCloseIcons) {
+            es.readArray([]).pipe(icons);
+          }
+
+          this.emit("end");
+        }
+      )
+    );
+
+  return es.duplex(input, es.merge(output, icons));
+}
+
+function createEntitlementsPlist(opts) {
+  var input = es.through();
+  if (!opts.darwinEntitlements) {
+    return input;
+  }
+
+  var contentsPath = path.join(getOriginalAppFullName(opts), "Contents");
+  var entitlementsPlistPath = path.join(contentsPath, "Entitlements.plist");
+
+  var result = {};
+  opts.darwinEntitlements.forEach((element) => {
+    result[element] = true;
+  });
+
+  var entitlementsFile = new File({
+    path: entitlementsPlistPath,
+    contents: Buffer.from(plist.build(result)),
+  });
+
+  return es.duplex(input, es.merge(input, es.readArray([entitlementsFile])));
+}
+
+function patchHelperInfoPlist(opts) {
+  var didCloseIcons = false;
+
+  var icons = es.through();
+  var input = es.through();
+  var output = input.pipe(
+    es.map(function (f, cb) {
+      if (
+        !/Contents\/Frameworks\/Electron\ Helper( \w+)?\.app\/Contents\/Info.plist$/i.test(
+          f.relative
+        )
+      ) {
+        return cb(null, f);
+      }
+
+      var contents = "";
+
+      f.contents.on("error", function (err) {
+        cb(err);
+      });
+
+      f.contents.on("data", function (d) {
+        contents += d;
+      });
+
+      f.contents.on("end", function () {
+        var infoPlist = plist.parse(contents.toString("utf8"));
+        var match = /\.helper\.([^.]+)$/.exec(
+          infoPlist["CFBundleIdentifier"] || ""
+        );
+        var suffix = match ? match[1] : "";
+
+        if (opts.darwinBundleIdentifier) {
+          infoPlist["CFBundleIdentifier"] =
+            opts.darwinBundleIdentifier + ".helper";
+
+          if (suffix) {
+            infoPlist["CFBundleIdentifier"] += "." + suffix;
+          }
+        }
+
+        infoPlist["CFBundleName"] = opts.productName + " Helper";
+        if (suffix) {
+          infoPlist["CFBundleName"] += " " + suffix;
+        }
+
+        if (infoPlist["CFBundleDisplayName"]) {
+          infoPlist["CFBundleDisplayName"] = infoPlist["CFBundleName"];
+        }
+
+        if (infoPlist["CFBundleExecutable"]) {
+          infoPlist["CFBundleExecutable"] = infoPlist["CFBundleName"];
+        }
+
+        f.contents = Buffer.from(plist.build(infoPlist), "utf8");
+        cb(null, f);
+      });
+    }))
+    .pipe(
+      es.through(
+        null,
+        function () {
+          if (!didCloseIcons) {
+            es.readArray([]).pipe(icons);
+          }
+
+          this.emit("end");
+        }
+      )
+    );
+
+  return es.duplex(input, es.merge(output, icons));
+}
+
+function addCredits(opts) {
+  if (!opts.darwinCredits) {
+    return es.through();
+  }
+
+  var creditsPath = path.join(
+    getOriginalAppFullName(opts),
+    "Contents",
+    "Resources",
+    "Credits.rtf"
+  );
+  var input = es.through();
+  var credits;
+
+  if (typeof opts.darwinCredits === "string") {
+    credits = vfs.src(opts.darwinCredits).pipe(rename(creditsPath));
+  } else if (opts.darwinCredits instanceof Buffer) {
+    credits = es.readArray([
+      new File({
+        path: creditsPath,
+        contents: opts.darwinCredits,
+      }),
+    ]);
+  } else {
+    throw new Error("Unexpected value for darwinCredits");
+  }
+
+  return es.duplex(input, es.merge(input, credits));
+}
+
+function renameApp(opts) {
+  var originalAppName = getOriginalAppName(opts);
+  var originalAppNameRegexp = new RegExp("^" + getOriginalAppFullName(opts));
+  var appName = getAppName(opts);
+
+  return rename(function (path) {
+    // The app folder itself looks like a file
+    if (
+      path.dirname === "." &&
+      path.basename === originalAppName &&
+      path.extname === ".app"
+    ) {
+      path.basename = opts.productAppName || opts.productName;
+    } else {
+      path.dirname = path.dirname.replace(originalAppNameRegexp, appName);
+    }
+
+    if (
+      /Contents\/MacOS$/.test(path.dirname) &&
+      path.basename === "Electron" &&
+      opts.darwinExecutable
+    ) {
+      path.basename = opts.darwinExecutable;
+    }
+  });
+}
+
+function renameAppHelper(opts) {
+  var originalAppName = getOriginalAppName(opts);
+  var originalAppNameRegexp = new RegExp("^" + getOriginalAppFullName(opts));
+  var appName = getAppName(opts);
+  var name = opts.productName;
+
+  return rename(function (path) {
+    var basenameMatch = /^Electron Helper( \(\w+\))?$/.exec(path.basename);
+
+    if (
+      /Contents\/Frameworks/.test(path.dirname) &&
+      path.extname === ".app" &&
+      basenameMatch
+    ) {
+      var suffix = basenameMatch[1] || "";
+      path.basename = name + " Helper" + suffix;
+    } else if (
+      /Contents\/Frameworks\/Electron\ Helper( \(\w+\))?\.app/.test(
+        path.dirname
+      )
+    ) {
+      var isInMacOS = /Contents\/Frameworks\/Electron\ Helper( \(\w+\))?\.app\/Contents\/MacOS$/.test(
+        path.dirname
+      );
+      path.dirname = path.dirname.replace(
+        /Electron\ Helper( \(\w+\))?\.app/,
+        name + " Helper$1.app"
+      );
+
+      if (
+        isInMacOS &&
+        /^Electron Helper( \(\w+\))?$/.test(path.basename) &&
+        path.extname === ""
+      ) {
+        path.basename = path.basename.replace(
+          /Electron\ Helper( \(\w+\))?$/,
+          name + " Helper$1"
+        );
+      }
+    }
+  });
+}
+
+exports.patch = function (opts) {
+  var pass = es.through();
+
+  var src = pass
+    .pipe(opts.keepDefaultApp ? es.through() : removeDefaultApp(opts))
+    .pipe(patchIcon(opts))
+    .pipe(patchInfoPlist(opts))
+    .pipe(patchHelperInfoPlist(opts))
+    .pipe(createEntitlementsPlist(opts))
+    .pipe(addCredits(opts))
+    .pipe(renameApp(opts))
+    .pipe(renameAppHelper(opts));
+
+  return es.duplex(pass, src);
+};

package/src/download.js

@@ -0,0 +1,205 @@
+"use strict";
+
+var path = require("path");
+const { downloadArtifact } = require("@electron/get");
+const ProgressBar = require("progress");
+var rename = require("gulp-rename");
+var es = require("event-stream");
+var zfs = require("gulp-vinyl-zip");
+var filter = require("gulp-filter");
+const { Octokit } = require("@octokit/rest");
+const got = require("got");
+
+async function getDownloadUrl(
+  ownerRepo,
+  { version, platform, arch, token, artifactName, artifactSuffix }
+) {
+  const [owner, repo] = ownerRepo.split("/");
+  const octokit = new Octokit({ auth: token });
+  const releaseVersion = version.startsWith("v") ? version : `v${version}`;
+
+  const { data: release } = await octokit.repos.getReleaseByTag({
+    owner,
+    repo,
+    tag: releaseVersion,
+  });
+
+  if (!release) {
+    throw new Error(`Release for ${releaseVersion} not found`);
+  }
+
+  const { data: assets } = await octokit.repos.listReleaseAssets({
+    owner,
+    repo,
+    release_id: release.id,
+  });
+
+  artifactName = artifactName || "electron";
+
+  const targetName = artifactSuffix ?
+    `${artifactName}-${releaseVersion}-${platform}-${arch}-${artifactSuffix}.zip` :
+    `${artifactName}-${releaseVersion}-${platform}-${arch}.zip`;
+  const asset = assets.find((asset) => {
+    return asset.name === targetName;
+  });
+
+  if (!asset) {
+    throw new Error(`Release asset for ${releaseVersion} not found`);
+  }
+
+  const requestOptions = await octokit.repos.getReleaseAsset.endpoint({
+    owner,
+    repo,
+    asset_id: asset.id,
+    headers: {
+      Accept: "application/octet-stream",
+    },
+  });
+
+  const { url, headers } = requestOptions;
+  headers.authorization = `token ${token}`;
+
+  const response = await got(url, {
+    followRedirect: false,
+    method: "HEAD",
+    headers,
+  });
+
+  return response.headers.location;
+}
+
+async function download(opts) {
+  let bar;
+
+  if (!opts.version) {
+    throw new Error("Missing version");
+  }
+
+  if (!opts.platform) {
+    throw new Error("Missing platform");
+  }
+
+  let arch = opts.arch;
+  if (!arch) {
+    switch (opts.platform) {
+      case "darwin":
+        arch = "x64";
+        break;
+      case "win32":
+        arch = "ia32";
+        break;
+      case "linux":
+        arch = "ia32";
+        break;
+    }
+  }
+
+  let downloadOpts = {
+    version: opts.version,
+    platform: opts.platform,
+    arch,
+    artifactName: opts.artifactName,
+    artifactSuffix: opts.artifactSuffix,
+    token: opts.token,
+    downloadOptions: {
+      getProgressCallback: (progress) => {
+        if (bar) bar.update(progress.percent);
+      },
+    },
+  };
+
+  bar = new ProgressBar(
+    `Downloading ${opts.artifactName}: [:bar] :percent ETA: :eta seconds `,
+    {
+      curr: 0,
+      total: 100,
+    }
+  );
+
+  if (opts.repo) {
+    const url = await getDownloadUrl(opts.repo, downloadOpts);
+
+    downloadOpts = {
+      ...downloadOpts,
+      mirrorOptions: {
+        mirror: `https://github.com/${opts.repo}/releases/download/`,
+        resolveAssetURL: () => url,
+      },
+      unsafelyDisableChecksums: true,
+    };
+  }
+
+  const start = new Date();
+  bar.start = start;
+
+  return await downloadArtifact(downloadOpts);
+}
+
+function downloadStream(opts) {
+  return es.readable(function (_, cb) {
+    download(opts).then(
+      (assets) => {
+        zfs
+          .src(assets)
+          .on("data", (data) => this.emit("data", data))
+          .on("error", (err) => this.emit("error", err))
+          .on("end", () => this.emit("end"));
+      },
+      (err) => cb(err)
+    );
+  });
+}
+
+function getDarwinLibFFMpegPath(opts) {
+  return path.join(
+    "Electron.app",
+    "Contents",
+    "Frameworks",
+    "Electron Framework.framework",
+    "Versions",
+    "A",
+    "Libraries",
+    "libffmpeg.dylib"
+  );
+}
+
+module.exports = function (opts) {
+  const downloadOpts = {
+    version: opts.version,
+    platform: opts.platform,
+    arch: opts.arch === "arm" ? "armv7l" : opts.arch,
+    artifactName: "electron",
+    token: opts.token,
+    quiet: opts.quiet,
+    repo: opts.repo,
+    symbols: opts.symbols,
+    pdbs: opts.pdbs,
+  };
+
+  if (opts.symbols) {
+    return downloadStream({ ...downloadOpts, artifactSuffix: "symbols" });
+  } else if (opts.pdbs) {
+    return downloadStream({ ...downloadOpts, artifactSuffix: "pdb" });
+  } else {
+    let electron = downloadStream(downloadOpts);
+
+    if (!opts.ffmpegChromium) {
+      return electron;
+    }
+
+    electron = electron.pipe(filter(["**", "!**/*ffmpeg.*"]));
+
+    let ffmpeg = downloadStream({
+      ...downloadOpts,
+      artifactName: "ffmpeg",
+    }).pipe(filter("**/*ffmpeg.*"));
+
+    if (opts.platform === "darwin") {
+      ffmpeg = ffmpeg.pipe(rename(getDarwinLibFFMpegPath(opts)));
+    }
+
+    return es.merge(electron, ffmpeg);
+  }
+};
+
+module.exports.download = download;

package/src/index.js

@@ -0,0 +1,146 @@
+"use strict";
+
+var path = require("path");
+var es = require("event-stream");
+var fs = require("fs");
+var rename = require("gulp-rename");
+var rimraf = require("rimraf");
+var symdest = require("gulp-symdest");
+var download = require("./download");
+var semver = require("semver");
+
+function moveApp(platform, opts) {
+  var appPath = platform.getAppPath(opts);
+
+  return rename(function (path) {
+    path.dirname = appPath + (path.dirname === "." ? "" : "/" + path.dirname);
+  });
+}
+
+function _electron(opts) {
+  var pass = es.through();
+  var result = es.through();
+
+  var buffer = [];
+
+  var src = pass.pipe(
+    es.through(function (f) {
+      if (!buffer) {
+        return;
+      }
+
+      buffer.push(f);
+
+      if (f.relative !== "package.json") {
+        return;
+      }
+
+      var json = JSON.parse(f.contents.toString("utf8"));
+      opts = { ...opts };
+
+      // We need to extract the application's name and version
+      // in order to feed it to the various platforms build
+      // process.
+      opts.productName = json.name;
+      opts.productVersion = json.version;
+
+      var platform = require("./" + opts.platform);
+
+      var sources = es
+        .merge(es.readArray(buffer), pass)
+        .pipe(moveApp(platform, opts));
+
+      var electron = download(opts).pipe(platform.patch(opts));
+
+      es.merge(sources, electron).pipe(result);
+
+      buffer = null;
+    })
+  );
+
+  return es.duplex(pass, es.merge(src, result));
+}
+
+function electron(opts) {
+  if (!opts.version) {
+    throw new Error("Missing Electron option: version.");
+  }
+
+  if (!opts.platform) {
+    throw new Error("Missing Electron option: platform.");
+  }
+
+  if (opts.ffmpegChromium && !semver.gte(opts.version, "0.36.7")) {
+    throw new Error(
+      "ffmpegChromium option is only supported in Electron versions >= v0.36.8."
+    );
+  }
+
+  if (opts.productName) {
+    console.warn(
+      "productName is deprecated. The application's name will be picked up automatically from package.json."
+    );
+  }
+
+  if (opts.productVersion) {
+    console.warn(
+      "productVersion is deprecated. The application's version will be picked up automatically from package.json."
+    );
+  }
+
+  return _electron(opts);
+}
+
+function dest(destination, opts) {
+  if (!destination) {
+    throw new Error("Missing destination.");
+  }
+
+  opts = opts || {};
+  opts.platform = opts.platform || process.platform;
+  opts.arch = opts.arch || process.arch;
+
+  var shouldUpdate = false;
+
+  try {
+    var version = fs.readFileSync(path.join(destination, "version"), "utf8");
+    shouldUpdate = version !== "v" + opts.version;
+  } catch (e) {
+    shouldUpdate = true;
+  }
+
+  if (!shouldUpdate) {
+    return;
+  }
+
+  var result = es.through();
+
+  rimraf(destination, function (err) {
+    if (err) {
+      return result.emit("error", err);
+    }
+
+    var stream = download(opts);
+
+    if (opts.platform === "win32" && opts.win32ExeBasename) {
+      stream = stream.pipe(
+        rename(function (path) {
+          if (
+            path.dirname === "." &&
+            path.basename === "electron" &&
+            path.extname === ".exe"
+          ) {
+            path.basename = opts.win32ExeBasename;
+          }
+        })
+      );
+    }
+
+    stream.pipe(symdest(destination)).pipe(result);
+  });
+
+  return result;
+}
+
+electron.dest = dest;
+module.exports = electron;

package/src/linux.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var path = require("path");
+var es = require("event-stream");
+var rename = require("gulp-rename");
+var semver = require("semver");
+
+function getOriginalAppName(opts) {
+  return semver.gte(opts.version, "0.24.0") ? "electron" : "atom";
+}
+
+exports.getAppPath = function (opts) {
+  return "resources/app";
+};
+
+function removeDefaultApp() {
+  var defaultAppPath = path.join("resources", "default_app");
+
+  return es.mapSync(function (f) {
+    if (!f.relative.startsWith(defaultAppPath)) {
+      return f;
+    }
+  });
+}
+
+function renameApp(opts) {
+  return rename(function (path) {
+    if (
+      path.dirname === "." &&
+      path.basename === getOriginalAppName(opts) &&
+      path.extname === ""
+    ) {
+      path.basename = opts.linuxExecutableName || opts.productName;
+    }
+  });
+}
+
+/**
+ * For Electron versions that support the setuid sandbox on Linux, changes the permissions of
+ * the `chrome-sandbox` executable as appropriate.
+ *
+ * The sandbox helper executable must have the setuid (`+s` / `0o4000`) bit set.
+ *
+ * See: https://github.com/electron/electron/pull/17269#issuecomment-470671914
+ */
+function updateSandboxHelperPermissions() {
+  return es.mapSync(function (f) {
+    if (!f.isNull() && !f.isDirectory() && f.path === "chrome-sandbox") {
+      f.stat.mode = 0o4755;
+    }
+    return f;
+  });
+}
+
+exports.patch = function (opts) {
+  var pass = es.through();
+
+  var src = pass
+    .pipe(updateSandboxHelperPermissions())
+    .pipe(opts.keepDefaultApp ? es.through() : removeDefaultApp())
+    .pipe(renameApp(opts));
+
+  return es.duplex(pass, src);
+};

package/src/win32.js

@@ -0,0 +1,152 @@
+"use strict";
+
+var fs = require("fs");
+var path = require("path");
+var es = require("event-stream");
+var rename = require("gulp-rename");
+var temp = require("temp").track();
+var rcedit = require("rcedit");
+var semver = require("semver");
+var { spawnSync } = require("child_process");
+
+function getOriginalAppName(opts) {
+  return semver.gte(opts.version, "0.24.0") ? "electron" : "atom";
+}
+
+function getOriginalAppFullName(opts) {
+  return getOriginalAppName(opts) + ".exe";
+}
+
+function getSignTool() {
+  let windowsSDKDir= "C:\\Program Files (x86)\\Windows Kits\\10\\bin\\";
+  if (!fs.existsSync(windowsSDKDir)) {
+    throw `There is no Windows 10 SDK installed at ${windowsSDKDir}.`;
+  }
+
+  let findSignTool = (start) => {
+    let signToolPaths = [];
+    fs.readdirSync(start).forEach(file => {
+      const filename = path.join(start, file);
+      const stat = fs.lstatSync(filename);
+      if (stat.isDirectory()) {
+        signToolPaths = signToolPaths.concat(findSignTool(filename));
+      } else if (filename.endsWith("signtool.exe")) {
+        signToolPaths.push(filename);
+      }
+    });
+    return signToolPaths;
+  }
+  let signToolPaths = findSignTool(windowsSDKDir);
+  let latestWindowsSDKVersion = signToolPaths.map(x => x.replace(windowsSDKDir, "").split("\\")[0]).pop();
+  let latestWindowsSDKSignTools = signToolPaths.filter(x => x.startsWith(`${windowsSDKDir}${latestWindowsSDKVersion}`));
+  let x64SignTool = latestWindowsSDKSignTools.find(x => x.includes("x64"));
+  if (x64SignTool) {
+    return x64SignTool;
+  }
+  let x86SignTool = latestWindowsSDKSignTools.find(x => x.includes("x86"));
+  if (x86SignTool) {
+    return x86SignTool;
+  }
+  throw `No supported version for signtool installed in ${windowsSDKDir}${latestWindowsSdkVersion}`;
+}
+
+exports.getAppPath = function (opts) {
+  return "resources/app";
+};
+
+function patchExecutable(opts) {
+  return es.map(function (f, cb) {
+    if (
+      f.relative !== getOriginalAppFullName(opts) ||
+      process.platform !== "win32"
+    ) {
+      return cb(null, f);
+    }
+
+    var patch = {
+      "version-string": {
+        CompanyName: opts.companyName || "GitHub, Inc.",
+        FileDescription: opts.productAppName || opts.productName,
+        LegalCopyright:
+          opts.copyright ||
+          "Copyright (C) 2014 GitHub, Inc. All rights reserved",
+        ProductName: opts.productAppName || opts.productName,
+        ProductVersion: opts.productVersion,
+      },
+      "file-version": opts.productVersion,
+      "product-version": opts.productVersion,
+    };
+
+    if (opts.winIcon) {
+      patch.icon = opts.winIcon;
+    }
+
+    var tempPath = temp.path();
+    var ostream = fs.createWriteStream(tempPath);
+
+    f.contents.pipe(ostream);
+    ostream.on("close", function () {
+      // Remove codesignature before editing exe file
+      const signToolPath = getSignTool();
+      const {error} = spawnSync(signToolPath, ["remove", "/s", tempPath]);
+      if (error) {
+        return cb(error);
+      }
+
+      rcedit(tempPath, patch, function (err) {
+        if (err) {
+          return cb(err);
+        }
+
+        fs.readFile(tempPath, function (err, data) {
+          if (err) {
+            return cb(err);
+          }
+
+          f.contents = data;
+
+          fs.unlink(tempPath, function (err) {
+            if (err) {
+              return cb(err);
+            }
+
+            cb(null, f);
+          });
+        });
+      });
+    });
+  });
+}
+
+function removeDefaultApp() {
+  var defaultAppPath = path.join("resources", "default_app");
+
+  return es.mapSync(function (f) {
+    if (!f.relative.startsWith(defaultAppPath)) {
+      return f;
+    }
+  });
+}
+
+function renameApp(opts) {
+  return rename(function (path) {
+    if (
+      path.dirname === "." &&
+      path.basename === getOriginalAppName(opts) &&
+      path.extname === ".exe"
+    ) {
+      path.basename = opts.productName;
+    }
+  });
+}
+
+exports.patch = function (opts) {
+  var pass = es.through();
+
+  var src = pass
+    .pipe(opts.keepDefaultApp ? es.through() : removeDefaultApp())
+    .pipe(patchExecutable(opts))
+    .pipe(renameApp(opts));
+
+  return es.duplex(pass, src);
+};